{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "4.DiffusionEquation.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "Y61YA90-WIZ1",
        "UoqCzgLSp61M",
        "i0j73GoH86-m",
        "pOe9yRvxjakj"
      ],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jdtoscano94/Learning-PINNs-in-Pytorch-Physics-Informed-Machine-Learning/blob/main/4_DiffusionEquation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Libraries"
      ],
      "metadata": {
        "id": "Y61YA90-WIZ1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " ! pip install pyDOE"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WZrPCr9GWEAJ",
        "outputId": "139c2953-fce4-4416-f0e0-935b4c80b092"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pyDOE in /usr/local/lib/python3.7/dist-packages (0.3.8)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from pyDOE) (1.4.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pyDOE) (1.21.5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.autograd as autograd         # computation graph\n",
        "from torch import Tensor                  # tensor node in the computation graph\n",
        "import torch.nn as nn                     # neural networks\n",
        "import torch.optim as optim               # optimizers e.g. gradient descent, ADAM, etc.\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.gridspec as gridspec\n",
        "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import matplotlib.ticker\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import numpy as np\n",
        "import time\n",
        "from pyDOE import lhs         #Latin Hypercube Sampling\n",
        "import scipy.io\n",
        "\n",
        "#Set default dtype to float32\n",
        "torch.set_default_dtype(torch.float)\n",
        "\n",
        "#PyTorch random number generator\n",
        "torch.manual_seed(1234)\n",
        "\n",
        "# Random number generators in other libraries\n",
        "np.random.seed(1234)\n",
        "\n",
        "# Device configuration\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "print(device)\n",
        "\n",
        "if device == 'cuda': \n",
        "    print(torch.cuda.get_device_name()) \n"
      ],
      "metadata": {
        "id": "OdYMzuSDi7Js",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc7c1686-9731-4c41-fe1c-c4ea328fd4c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tunning Parameters"
      ],
      "metadata": {
        "id": "UoqCzgLSp61M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "steps=20000\n",
        "lr=1e-3\n",
        "layers = np.array([2,32,32,1]) # hidden layers\n",
        "# To generate new data:\n",
        "x_min=-1\n",
        "x_max=1\n",
        "t_min=0\n",
        "t_max=1\n",
        "total_points_x=200\n",
        "total_points_t=100\n",
        "#Nu: Number of training points # Nf: Number of collocation points (Evaluate PDE)\n",
        "Nu=100\n",
        "Nf=10000"
      ],
      "metadata": {
        "id": "L2r-CxAnp5Ub"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Auxiliary Functions\n"
      ],
      "metadata": {
        "id": "i0j73GoH86-m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def plot3D(x,t,y):\n",
        "  x_plot =x.squeeze(1) \n",
        "  t_plot =t.squeeze(1)\n",
        "  X,T= torch.meshgrid(x_plot,t_plot)\n",
        "  F_xt = y\n",
        "  fig,ax=plt.subplots(1,1)\n",
        "  cp = ax.contourf(T,X, F_xt,20,cmap=\"rainbow\")\n",
        "  fig.colorbar(cp) # Add a colorbar to a plot\n",
        "  ax.set_title('F(x,t)')\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  plt.show()\n",
        "  ax = plt.axes(projection='3d')\n",
        "  ax.plot_surface(T.numpy(), X.numpy(), F_xt.numpy(),cmap=\"rainbow\")\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  ax.set_zlabel('f(x,t)')\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "F8Y6q7m288zJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot3D_Matrix(x,t,y):\n",
        "  X,T= x,t\n",
        "  F_xt = y\n",
        "  fig,ax=plt.subplots(1,1)\n",
        "  cp = ax.contourf(T,X, F_xt,20,cmap=\"rainbow\")\n",
        "  fig.colorbar(cp) # Add a colorbar to a plot\n",
        "  ax.set_title('F(x,t)')\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  plt.show()\n",
        "  ax = plt.axes(projection='3d')\n",
        "  ax.plot_surface(T.numpy(), X.numpy(), F_xt.numpy(),cmap=\"rainbow\")\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  ax.set_zlabel('f(x,t)')\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "pFS1eS92dhuX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem Setup\n",
        "https://deepxde.readthedocs.io/en/latest/demos/pinn_forward/diffusion.1d.html\n",
        "\n",
        "**Diffusion equation**\n",
        "\n",
        "$$\\frac{\\partial y}{\\partial t} =\\frac{\\partial^2 y}{\\partial x^2}-e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))$$\n",
        "\n",
        "$$x\\in[-1,1]$$\n",
        "$$t\\in[0,1]$$\n",
        "\n",
        "### Initial Condition:\n",
        "\n",
        "$$y(x,0)=sin(\\pi x)$$\n",
        "\n",
        "### Boundary Conditions:\n",
        "\n",
        "$$y(-1,t)=0$$\n",
        "$$y(1,t)=0$$\n",
        "\n",
        "### Exact solution:\n",
        "\n",
        "$$y(x,t)=e^{-t}sin(\\pi x)$$"
      ],
      "metadata": {
        "id": "koofMp-5Y-UA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Analysis:\n",
        "## PDE\n",
        "$$\\frac{\\partial y}{\\partial t} =\\frac{\\partial^2 y}{\\partial x^2}-e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))$$\n",
        "\n",
        "If we rearrange our PDE, we get:\n",
        "\n",
        "$$\\left(\\frac{\\partial y}{\\partial t} -\\frac{\\partial^2 y}{\\partial x^2}\\right)+e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))=0$$\n",
        "\n",
        "## Neural Network\n",
        "\n",
        "A Neural Network is a function (See:https://book.sciml.ai/notes/03/):\n",
        "\n",
        "$$NN(X)=W_n\\sigma_{n-1}(W_{n-1}\\sigma_{n-2}(...(W_2(W_1X+b_1)+b_2)+..)+b_{n-1})+b_n$$\n",
        "\n",
        "**Note:**We usually train our NN by iteratively minimizing a loss function ($MSE$:mean squared error) in the training dataset(known data).\n",
        " \n",
        "## PINNs=Neural Network + PDE \n",
        "(See: https://www.sciencedirect.com/science/article/pii/S0021999118307125)\n",
        "\n",
        "We can use a neural network to approximate any function (Universal APproximation Theorem): (See:https://book.sciml.ai/notes/03/)\n",
        "$$NN(x,t)\\approx y(x,t)$$ \n",
        "\n",
        "Since NN is a function, we can obtain its derivatives: $\\frac{\\partial NN}{\\partial t},\\frac{\\partial^2 NN}{\\partial x^2}$.(Automatic Diferentiation) \n",
        "\n",
        "Assume:$$NN(t,x)\\approx y(t,x)$$ \n",
        "\n",
        "Then:\n",
        "\n",
        "$$\\left(\\frac{\\partial NN}{\\partial t} -\\frac{\\partial^2 NN}{\\partial x^2}\n",
        "\\right)+e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))\\approx \\left(\\frac{\\partial y}{\\partial t} -\\frac{\\partial^2 y}{\\partial x^2}\\right)+e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))=0$$\n",
        "\n",
        "And:\n",
        "\n",
        "$$\\left(\\frac{\\partial NN}{\\partial t} -\\frac{\\partial^2 NN}{\\partial x^2}\n",
        "\\right)+e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))\\approx 0$$\n",
        "\n",
        "\n",
        "We define this function as $f$:\n",
        "\n",
        "$$f(t,x)=\\left(\\frac{\\partial NN}{\\partial t} -\\frac{\\partial^2 NN}{\\partial x^2}\n",
        "\\right)+e^{-t}(sin(\\pi x)-\\pi^2 sin(\\pi x))$$\n",
        "\n",
        "If $f\\rightarrow 0$ then our NN would be respecting the physical law.\n",
        "\n",
        "### PINNs' Loss function\n",
        "\n",
        "We evaluate our PDE in a certain number of \"collocation points\" ($N_f$) inside our domain $(x,t)$. Then we iteratively minimize a loss function related to $f$:\n",
        "\n",
        "$$MSE_f=\\frac{1}{N_f}\\sum^{N_f}_{i=1}|f(t_f^i,x_f^i)|^2$$\n",
        "\n",
        "Usually, the training data set is a set of points from which we know the answer. In our case, we will use our boundary(BC) and initial conditions(IC).\n",
        "\n",
        "#### Initial Condition:\n",
        "\n",
        "$$y(x,0)=sin(\\pi x)$$\n",
        "\n",
        "#### Boundary Conditions:\n",
        "\n",
        "$$y(-1,t)=0$$\n",
        "$$y(1,t)=0$$\n",
        "\n",
        "Since we know the outcome, we select $N_u$ points from our BC and IC and used them to train our network.\n",
        "\n",
        "$$MSE_{u}=\\frac{1}{N_u}\\sum^{N_u}_{i=1}|y(t_{u}^i,x_u^i)-NN(t_{u}^i,x_u^i)|^2$$\n",
        "\n",
        "\n",
        "#### Total Loss:\n",
        "\n",
        "$$MSE=MSE_{u}+MSE_f$$"
      ],
      "metadata": {
        "id": "XYwWBwmbp3S6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions"
      ],
      "metadata": {
        "id": "K40IpAXPjS4I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def f_real(x,t):\n",
        "  return torch.exp(-t)*(torch.sin(np.pi*x))"
      ],
      "metadata": {
        "id": "hZFwvWyGs2RE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Neural Network"
      ],
      "metadata": {
        "id": "ZHYqtyYJs3Jv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FCN(nn.Module):\n",
        "  #https://github.com/omniscientoctopus/Physics-Informed-Neural-Networks/tree/main/PyTorch/Burgers'%20Equation\n",
        "    ##Neural Network\n",
        "    def __init__(self,layers):\n",
        "        super().__init__() #call __init__ from parent class \n",
        "        'activation function'\n",
        "        self.activation = nn.Tanh()\n",
        "        'loss function'\n",
        "        self.loss_function = nn.MSELoss(reduction ='mean')\n",
        "        'Initialise neural network as a list using nn.Modulelist'  \n",
        "        self.linears = nn.ModuleList([nn.Linear(layers[i], layers[i+1]) for i in range(len(layers)-1)]) \n",
        "        self.iter = 0 #For the Optimizer\n",
        "        'Xavier Normal Initialization'\n",
        "        for i in range(len(layers)-1):\n",
        "            nn.init.xavier_normal_(self.linears[i].weight.data, gain=1.0)\n",
        "            # set biases to zero\n",
        "            nn.init.zeros_(self.linears[i].bias.data)   \n",
        "    'foward pass'\n",
        "    def forward(self,x):\n",
        "        if torch.is_tensor(x) != True:         \n",
        "            x = torch.from_numpy(x)                \n",
        "        a = x.float()\n",
        "        for i in range(len(layers)-2):  \n",
        "            z = self.linears[i](a)              \n",
        "            a = self.activation(z)    \n",
        "        a = self.linears[-1](a)\n",
        "        return a\n",
        "    'Loss Functions'\n",
        "    #Loss BC\n",
        "    def lossBC(self,x_BC,y_BC):\n",
        "      loss_BC=self.loss_function(self.forward(x_BC),y_BC)\n",
        "      return loss_BC\n",
        "    #Loss PDE\n",
        "    def lossPDE(self,x_PDE):\n",
        "      g=x_PDE.clone()\n",
        "      g.requires_grad=True #Enable differentiation\n",
        "      f=self.forward(g)\n",
        "      f_x_t = autograd.grad(f,g,torch.ones([g.shape[0], 1]).to(device), retain_graph=True, create_graph=True)[0] #first derivative\n",
        "      f_xx_tt = autograd.grad(f_x_t,g,torch.ones(g.shape).to(device), create_graph=True)[0]#second derivative\n",
        "      f_t=f_x_t[:,[1]]# we select the 2nd element for t (the first one is x) (Remember the input X=[x,t]) \n",
        "      f_xx=f_xx_tt[:,[0]]# we select the 1st element for x (the second one is t) (Remember the input X=[x,t]) \n",
        "      f=f_t-f_xx+ torch.exp(-g[:, 1:])* (torch.sin(np.pi * g[:, 0:1]) - np.pi ** 2 * torch.sin(np.pi * g[:, 0:1]))\n",
        "      return self.loss_function(f,f_hat)\n",
        "\n",
        "    def loss(self,x_BC,y_BC,x_PDE):\n",
        "      loss_bc=self.lossBC(x_BC,y_BC)\n",
        "      loss_pde=self.lossPDE(x_PDE)\n",
        "      return loss_bc+loss_pde\n",
        "\n",
        "    #Optimizer              X_train_Nu,Y_train_Nu,X_train_Nf                   \n",
        "    def closure(self):\n",
        "      optimizer.zero_grad()  \n",
        "      loss = self.loss(X_train_Nu,Y_train_Nu,X_train_Nf)\n",
        "      loss.backward()      \n",
        "      self.iter += 1\n",
        "      if self.iter % 100 == 0:\n",
        "        loss2=self.lossBC(X_test,Y_test)\n",
        "        print(\"Training Error:\",loss.detach().cpu().numpy(),\"---Testing Error:\",loss2.detach().cpu().numpy())\n",
        "      return loss   "
      ],
      "metadata": {
        "id": "7EZjlbVMi8w0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Generate data"
      ],
      "metadata": {
        "id": "pOe9yRvxjakj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x=torch.linspace(x_min,x_max,total_points_x).view(-1,1)\n",
        "t=torch.linspace(t_min,t_max,total_points_t).view(-1,1)\n",
        "# Create the mesh \n",
        "X,T=torch.meshgrid(x.squeeze(1),t.squeeze(1))\n",
        "# Evaluate real function\n",
        "y_real=f_real(X,T)\n",
        "plot3D(x,t,y_real) #f_real was defined previously(function)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "go0WGbdx7bXB",
        "outputId": "a4a63e95-4e99-42ee-9ced-2204e00f9319"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/functional.py:445: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at  ../aten/src/ATen/native/TensorShape.cpp:2157.)\n",
            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZAk133n93kv77q7+pwbmAEwwOAGBhCgkyKXQVFhUscqTNKKNdc0Q9pdSVbIYWlhWaJ1rMXdWFuMlSjZkixbio2QaK3ksBDykhRXooIiZYEHABEAQRBzHz0zfdWZVXm+5z+yru7pnqmeo2cGqG/ExFRXZVZmVmV+6pe/9/39ntBaM9FEE0000c5I3uodmGiiiSZ6O2kC3YkmmmiiHdQEuhNNNNFEO6gJdCeaaKKJdlAT6E400UQT7aDMq7w+sTZMNNFEE21fYqsXJpHuRBNNNNEOagLdiSaaaKId1AS6E0000UQ7qAl0J5poool2UBPoTjTRRBPtoCbQnWiiiSbaQU2gO9FEE020g5pAd6KJJppoBzWB7kQTTTTRDmoC3YkmmmiiHdQEuhNNNNFEO6gJdCeaaKKJdlAT6E400UQT7aCu1mVsoom2lNYapRRhGJIkCaZpIqXEMAyklEgpEWLLZksTTfS2lLjKxJST1o4TXSatNWmakiTJusf910ZB24dw/98ExhO9TbTlCT6B7kRjayNshRAIIUiShCRJkFJetvzov9OnTzM3N0cul5vAeKK3urY8kSfphYmuKq01SZJw7tw5SqUS+Xz+MsBupj6U+4qiCGCwbpIkxHG8bp0JjCd6q2sC3Ym2VB+2/dRBo9HAdV0KhcI1vZ8QYl36YSNI+3ddfRhvXNYwjEHeuA/nCYwnutM0ge5El0kptS5P249YpZQopS5b/kaB72ow3pja0FpfMTKeAHmi21ET6E40kFKKJElI0xS4PD3QB9216lrXHxfGG9dptVpMT09PYDzRbaUJdN/m6g9yxXE8iGK3ApOU8pZA90rvN/p/X/1tvPHGGzz55JOXrdOPjkdTFRMYT7RTmkD3baq+xzZJEl5//XUOHz58VfAIITZNL4yrGw3dq22nnwceVf+40zQdDOz1NZqm6EfHExhPdKM1ge7bTKOwVUohhKBWq43tRtgJaN5MbQXRURhv9BpvljOeOComulZNoPs20VYe2+2A43ZLL9xIXQuMJ/a2ia5FE+i+xbUZbMeJajfTnZJeuJG6Eoz7ufAoihBCcPz4cQ4dOjSB8URX1AS6b1H1PbajEdq1wravGwHNOw26W2kzGDcajUnhx0RX1QS6bzH1YXv27Fny+Tzlcvm6YdvX9fp0dxoutwJm4xZ+jKoP30nhx9tDE+i+RbSxoKHT6WCa5g29cO+k9MJOR9RX296k8GOivibQvcO1VUGDYRjbAuTGQaLNtBGaWmvW1tY4ceIEQRDgOA75fH7dP9M0t1x/omsv/NgMyBMY3xmaQPcO1DgFDVulAjaTEcfoV19FzEzDrt1bLtd3L2itWVlZ4cSJE3iex+HDh7EsiyRJ8H0f3/e5cOECvu+TpukAxt1uF2DQe/etpHF+tLajq8FYKcXJkyfxPI/Z2dnBspPCj9tfb60z/y2ujR5buHL12FWhm6bI3/5tvu1f/2vsOEY99hhUKqQf+0X0Qw9vukqz2eSFF16gUCjw0EMPkc/nUUoRRRGO4+A4DtVqdd0+R1FEu93G933W1tZYXV1dB+PRfxuLGe4U3WjobqVRGGutB5Fufx8mhR+3vybQvQPUv5jq9TqtVouFhYWrXjBSykHKYVPFMeaP/ijG888Tl8ukDz+McfIk6v77MP7HXwQ0yX/5T+EHfgitNRcvXuTNN9/ENE0ef/xxPM8ba9+FEAMY+76PbdssLCygtSYMw0FkfP78eXzfRym1DsaFQoFcLnfbw3inoLtxm6ODpNvxGo9W7E0KP3ZWE+jextrosY2iiFqtxq5du666rpTyslHyUZnP/Syivoretw/r7FkSlaJLOUQUIv72C7B7N9Z/+98Q/Oav8+qHP4Lz1LMcOnQI3/fHBu5GjeZ0hRC4rovrukxPT6875iAI6HQ6+L7P2bNn6XQ6KKVwXXddVHw7wfhWQFcpdU19jfuaFH7cGk2gextqq4KG7QyOXSm9IJ//c4z/4/ezbVkWq+96B1NvvolcXoITJ0gfe5RutUr+77+Ie+IYR//Nr8KuBVZ+9X+mValu+p43sr2j53l4nrcpjPuR8dra2qYw7kfGO63bGbpbaTuFH331B0w9z5vA+Bo1ge5tpKsVNBiGceWUwYi2hG6zifzTP0YXi4hWC33gAFOvvIgwDNLv/i7ixQuIS4sUvvkq6b2HEWmMXDyNWpFM/4sP4+3dD7/wK/D0d2z7+K7HvTAK45mZmcHzozBut9usrq7S6XQGz584cWJdZHyjPMsbdSdCdytdCcaLi4tUq9XLXp9ExuNrAt3bQBtnaNiqemw7joStljV+6xMYf/M5dKVC+tSTiNVVZG/QJX3tFcTueYy7HkS/+BLyzEn00aPopItoNZF+QK7TQf74P0E9eZTkv/+f4NC9g2PYruXsRmgrGCdJwosvvkixWMT3fVZWVgYw9jzvsjTF9cLrrQTdrSSEIE1TTNNcl9YZt/BjAuNME+jeQiml6Ha71Go1pqenxxocuy7oLl3C+D9/DwBRr6Mtge7UqD3yMFOvv4Hx4AMYX38Jzp5GV6dJnziK8cUvIILM6pXunoUwQLTayK9+GftH/zP0gbsIf/UTiAOHxtqvnfLp9geJZmdnB5aq/va73e4gTdGHMXAZjD3PGxtqbwfo9re5MY9+PYUfo9a2t4ujYgLdW6DRgoZOp8Pi4uI6MGyl7aQXNsv/yuf/A5QKEHRJc3n0G69hdXymGzXC73kWC4G2LEQco+9/APML/wk9PUN61+OIS+cwzp0HQFdLoEFEPlw4h/PPPoi1dz/Bv/iX6Ce+bct9uh2KI4QQ5HI5crncus+8/wPYh/HS0tLAVzwOjN8u0E3TdOzBy+sp/NgsMn6rwHgC3R3SVgUNlmVdf552i2XXva/fxvz3v422E+pPPYFtueRf+goAyrYwz59Gri6jD+wmPXgY+XdfzPZxdQVx190IlaB2TSMuroFKQKXoYgmiCFnvQByS+4WfIL3nPsIP/yT6yW+/bJ9uB+huJSnlAKqjuhKMc7ncYJ2dhl9/325n6G6lcQo/wjAcPB/HMY1Gg/n5+bdE4ccEujdZVytouCGDY5totE9Ct9ul9b9/kn1+GwFULp2BqQrqHd+NeOU1Onv3U/jm17MVV5YQpQLctRs1vQDnFhEn3kB0fASg5gtQKCHOXULUGmAI9O5pRDdC1OuI117G+MWfQs8v0P3n/xL99Hev26fbFbpb6Uow7tvaWq0WjUaDVqvFV77ylXUw7kfGNwMMdyp0t9JWMO52u6yurjI7O3vVwo9+UFMqlW7KPt4ITaB7k7TZDA2b/SpvF6Tjqu/TffXVV2m1Wnz7Fz473LeHHkV+/SuI1SV0sYSeypFOz2CsrqCfeAr56tey7S1dID36DET74GtfRbsuQsWIlVV0xUPn8xBGiFoze9+Sh8oVkO0mYuUCuY//d+ipKuGP/nPSd/3A2Pt+J0hKSaFQGExH32q1OHfuHIcPH14H44sXL9Ltdgdpjb6tLZ/P47rudcG4f17tpG4F6Ptl45ttd9RrDPDZz36Wf/iHf+DXfu3XdnQft6MJdG+w+pVWURRhWdaWsO1rO5HuuGq32xw7doxGo8GBAwd4yEoxZ2bQ588gkhhWLw33974HKH7jRZRjk77jexCrq4PX1KNPYHw9S0Hou/aQHLof64ufz16MUoQboNEks2WMWhssidGoo/IOSmmMto+WGuf3/y36T3+fyrP/iEvf9b4beqy3i/qDQxth3Fc/Mm632zQaDRYXFwmCACnlZZHxdmB8K9IaOw36K0XXG6+tRqNBuVzeqV27Jk2ge4M0WtCwvLxMrVbj8OHDV13vRp7ArVaL48ePE0URBw4cIAxD5ubmMP/0f0Oefw19aA/pnnuRX/5Sts9CIGrLAMg4QpkC0bxA+u3fgTh1GrG2PDy+6RnsF/+WaK6KaUt0EGDUs5SDGbVhLoey8xCtIf0QWbJRuTwojVGro1tNSv/vH5H7/J/TeuYfEfzAP6UwVcW27ZtyEe/0wNbV0iZbwbg/mOr7/qYw7kfF+Xwex3HuuPzljdB2GiQ1Gg0qlcpN3qPr0wS616nNChq2Mzh2I9RoNDh+/DhKKQ4ePEi1WiVNU06ePAlJjPziZwAQjRXEgbtg/xyquhfdDTGOvZIdhxCItSVEEmN880XUI0+iFWjLRCyeg8AHwG43SaYKmIZC3b2AOLsM00VErYUkRNsGej4PjRDZyqxYFG1UeQp7aQVLJbhfeB71pU+zfP8TvPpdPwi54jq45PN5bNvesc/vRuhab/UNw6BYLFIsFtc934dxu92mVqtx7tw5wjBcl2NOkmRQIbZTML4VOfntQvfAgQM3eY+uTxPoXqOuVNBwM1IGm6lWq3H8+HGklBw8eHDdL3w/Vyxf+jtEs57ts+MiTn0LEXQQ7Trpo0+TTj0L33iVeH437rlj2XJCIGoriEvn0FISveNdqBNv4vVek8UKXLyAXF5DL+TBMdEdGxFG6KkSstFEmwaUcyhtIfwOxtIK2rXAkAjPxYxCFt78Ggsnv05870Os/tA/oykEy8vLnDp1ijiOsSxrXQ50Y3/e2003EnxXgnHfSZEkCW+88QZhGGIYxmWR8c26i9hpJUmC4zhjLTuJdN+C2jhDw2b52psJ3dFetrZtc9999206UtvfJ/l3nxuue+gBZD+yzReRJ15FJBGqYpPsmkd3m4jVJdR9D2Gc/EZ/g6jzb+IFK6RPPE4tgJljXx9uyM0h1hpoz4CFMsLvfS5JihYuMo1QC9Ow1kBLAyEUhAEYCuGHkPcwT3+ThX/3M8zuu5voff816vGnAIii6Ir9eW+nLmQ7lc4wDINSqUSpVOLs2bM8+uijQAamfppibW2Ns2fPDmC8sX3mtcL4VgzcAYMquHHUbDYn0H2raKsZGjbTtUD3ahdtH7bdbpdz585x5MiRy/KDGyVUirz4CulTzyKPHQNGZn04eBh57OXs2Lwc+XOvgCNQR58mTQV9hEV3H8Y79yYA8vS3yE/Poh55GNpNhN9ErDWybSUp2rQR2s/SDvUmCAmpRq7V0Y6JyFnoUCFbXbRpIMoOyssh6w3QYAavYvyv/wPprn1E3/0D2N/xPuypKaamptZ9DqP9eUe7kI0WMbiuu6O3wreiOGJ0e6ZpDmA8qtHG8qurq5w5c4Yoii6DcaFQGAz8bqWbaRe7kraTXmg2m5OBtDtZowUNx44dY3Z2llKpdNWLa7vQ7acCNjuhtdYsLS1x4sQJisUs93nkyJGxcp6VS8cRjWWMxjJ6vgSVPGr3fuTiGQj9wXLxrv2Yp18DDVHjInbYJHzwEaxOgGUMR8fVfQ/hnXwNmitoIRHzeXRpGs7WYCqHqLWz41leQ8/lEQq0m4dmF/I5RDsbeGM2D44Dqy1k2EBLCUUHUo1otzDPHcf81L9DffoPib7t3STf91+Bnd1ejvbn3diFbGMRQ7vd5itf+Qqe56277b4ZvtnbbeCuL9M0KZfLl4FoI4xPnz5NHMeYprlpZAyblwDvhLab0x39kb4dNYHuJtqsoCGOY5IkGevCMgzjsvLGqy2/MYroNw4/deoU5XKZxx57DM/z+NrXvja2r3fm3GvD99t9F/LMa2BC+sx3IFrN4fabQ5uYXtiLOP0azuoJ1NxekAbq8KOIb72CiIPBcurehzFOvYoA9K4SomShwxgRJeiKh6hnywqA/WV0oKCd5YRxXETLR0+XEEmIdnLIejPLJRcslGkihER027h//Sfo/+8/khx+gvB9PwbTm08ntLG8N0kSvv71r/PYY4/R7XZpt9vrfLM32h1wK6B7PdvbCsZxHA9gPJpfN00Tx3EIw5BarTaIjHdCSZKMDftJTvcOU9/2labpZQUNpmluq3JsOxrtk6CUYnFxkTNnzlCtVnn88cdxXXfdsuPux/S5bwz/ECORUd5CLp8nOXwfbeVSOvtNIAOiUx96eJmaG6Qg0qNHIRGkF22MJEKE7eFyRRtqHUTFQVXmEB0fOlnVkC65sNbJqtlmS0hXopezdUXLR1fzyChAzZSRa01UqYKo1aBYQIYddCpAaszjL2L+Lz+G2ncP4ff+F6j7nx7rM9iqomwrd0D/tnvjgNTVtNPQvVn5VcuyqFQql4ErjmOWl5fpdrssLy9z8uRJkiQZDHaO/rvRMN5OTjdN0x37MbhWTaDL5k3DN+ZsTdPcVvS6HfWrx5aWljh79iyzs7McPXp004t93Ao2sXgcz68BoE0LceHk4DXdyaJcs3UR966H0HKBtjGFJw2MU69myxgWYvH48P0cC7n4CvFsEX3gIYxjWRStARH3PpdEZWdUqtAHq+hGhBAggl67P6Gh1UUUbXQ+j0hDRC2LiGXUhtk8QsRgG4hWG1WdQqQRkCAaPphmdlyf+jVUZZb40XeQfPcHwLj8NL4aBLdyB4zedm/mpBgF8igIdrpSa+NUPTdblmWRy+UolUrcd999g+dHBzsvXbo0cFXcSBiPm164U0rM39bQ3WqGhs203ZTBuErTlG63y0svvcTu3bt5+umnr3hyjhvpinOvULvrMJX6Gro8jbyQDYZFbgFr6fRgObuzhgxbFGiRHnoMVTwKly6iCxWM01mkrJ0cojeYZiUBihBchdr/JEmwin3mbLYcIIIuQmuod9ELMxAHqLyDuFgHx4QwgigFJ83gvFCGRgeRt6EZZOkKKWHOQ8Qxops9pyplkCB9HzRIrXA+/8fYX/s0yaHHib73n0Bl7tq+hBFtdds9CpeLFy/SbrfXOSn6t+A7Ndh0q/oubNymbdvYtn1ZHvVKMN7oyR4HqONE9aNTQd3OeltCt1+qu7q6OuiCf7UT2DTNdZ2PrldJknDmzBkWFxcxTZMjR46sa8K9lcaNdI2TX2ZKLqOrgnh+gSTqkl89h54/gFjM0glqdh+yvpg9lgZy+SQiaIMJycK9KHkEcep19IH7kKcyq1noFLDPvYFQKeLiN5H7DhDdVYUgAcPCXu55ggWIbidrhAOkD+xHBB20H2SwdU1EI0A0fHQ+B45AT2VFFpRdtB9mAK6WEDpCtDsIpTIgl/JgWYhmE9FtY7/yN1jf+BLp3nuIvu2HUPc/e21fyhW0GVxGnRR9S9tLL700mEJoFC43etaK26WX7lba6vOK43jgPBm1Adq2fVlkvF1PdhAEt2Sqpu3qbQXd0YKGKIo4efLkWKCDDLq+7199wRFtdmHEcczp06e5dOkSe/bs4dlnn+XYsWNjv+dVZ/kFiALEYhalCjS6fZZ8qYNauB/TnUEvO4g4hMoMNDLodqf2kG/1+uU6eYyLryLSBHXfwawpjpNDhB06lXmctVPZ8VXnMS6dx+xZ0TrTFXTRxDpbJ54t4az0GuEIgex0Ed0QPZ0jrRQxLvVSH4DOOYhGK4tod1eROkF3I1A662LWUVDw0IZAxBE6iZHdLqpYREQB2ssh0hhj6RS5//vjpNO7kPc+gygeGftzvRaNOimCIEBrzd69ewdTBfXhslmj9D6Qr9VJcSd2GBNCYNs21WqVanU4117/x2srT3YQBFy4cGHw47UVjOv1+m3dXayvtwV0NytosG37mhwG46p/q9m/MKIo4tSpUywvL7Nv3z6effbZdRVs4zoSxlk2ePPLOGl2bHFhBjfMACfCGiJtwf5pUnc3YiRyV9Ywf6wXDiL70DYEcvkV9FyetHQEubIyWK6Tm6LQzv6OSx65WhblqmmPZKqAjGKsZpdwoYy70spWSjWyE4JtkM6WUFphXcpe04A2TGh0IO+i8xbC78E3CNHFAtqWaNeBRhMRBVn+N4nRjo1oNdHFAjJo4b34FzwtPoM4/wjxM/85auHesT7f69Foa8L+FEJbNUq/XifFnQjdrTT647URxkEQ8A//8A8kScL58+fpdDqXFcj0YXwnOBfgLQ7dKxU0bLe363YH0vqQTtOUU6dOsba2xoEDB7jnnnsuu1i2OyPEVss2m02OHz/Ovje+wCAjWZmHflQ5sx+5kg2oSV0Dmqgjj5C2Ipz6heEbqeE8V2pqF4a/ikhChBFSsut07r6PuNEh3xo6HVTOhiBzLCRFl/xaNh1QeHAaLYws3wsEcyW85SwCls0OIueidhVRwoY0wlzLXhNxQmqVkEaM3lVFdrsQR4goRYQhKp8Hz4YoQTZbWWP1Sh4MO0trxDEy5yHPvY75f/0CamYv8QPfRfLo++AmgGOcga1RJ8Xc3DD/PNr0ZjMnxWhkPOqZvRXQ3cmeGP0pl1zXZd++fYPn++nBfmR8/vx5fu/3fo+/+qu/AuC5557jwQcf5Pu+7/uuOCPLZz7zGX76p3+aNE356Ec/ynPPPbfu9Z/5mZ/h85/Puup1Oh2Wlpao17PAwjAMHn74YQD279/P888/P/ZxveWgu9UMDdebXL+WgbQ33ngD3/e5++67OXz48Jb7MFbKYGTZjZFus9nk2LFjKKU4dOgQc68Ou4Nlo/89Wd7goZ7ahbzUQLTPoqb2oqwiyrsPVhYRS0Ong+g5IAC60iYvBLngIuld9yH9NZR1D1w6i9lsDN/bMoEsJ4sh8Rodkj1lYtPGbA5TNMHCFN5KAyIQRkJacEn2lBFrAapoYdV71W7NNulMFZlEKAxkvYEwUkQzA7SarYIpELUmUgVoQ6KmyxClyFYdLAtZu4D99/8B+8W/IDnwMPGT/xhd3TvWZz6OrscyNo6TYmVlZZ1n1rIskiSh0WjsWE+KzQbSbrY28+gKIXBdF9d1BwUyv/7rv86nP/1pPv/5z/M93/M9fOMb36Ber28J3TRN+Ymf+Ak+97nPsXfvXp566ine//73c+TIMCX1iU98YvD4N3/zN3nppZcGf3uex8svv3xNx/SWge7VZmi4Xo3r0+10Opw4cYJ6vc7Bgwd55JFHbmgF2yh0+93FtNYcOnQou7UKW4hiQlp+gvjsaZz6+cG6wh8WQaCGPyDaLeA0z4N/HHX3/ahwF6LVgU4bWcvWVwic9jCyFYZEBDVEUCM9+ABBdwnRqGF2Y6x6Z7gc2UVqdiKSGRvDNQlmZpHNGHsUwHNlvF4OWOUMyNskQmDWOsSzhSGAgWRhBpkmoH1IUiBBNgO0Y5CWqlmU22wjAe256HwO0e0igggtJfabL2CdepG0skDywPeSPPgeuM7z5Gb4dK9UwLC4uEitVlvnpLBt+zJnwI1MB9yKirTt9l3Yv38/733ve3nve997xWW//OUvc88993Dw4EEAPvjBD/Lnf/7n66A7qj/+4z/ml3/5l7e381vojofuaEHDyy+/PIDcuBfAuBfL1dIL7XabEydO0O12OXjwIEIIKpXK2BVsG6cgudKy9Xqdr30tm91hANue5PI3EamPkfqEB+ZItMSIDWiuIJsZNLVhImpnh+t0h9EsAoz2aRDQ2n2IZC1PqbkEUwuYvQE0becQq6eGqyRd8q01kLB2aAarnZK7uEqcz+E2hmA1EoFMFW6jQ3e2iE4d4iTBWulg10cAPFMit5oBONkzjZYKbYSIVBFP57F6t3haCsLdM1h+NmcZSiN0ggi7pNUiaayx0MhGAy1Al4ogJcQxIu5gtJYwv/TvUS//PyS7jxA98Y+hsmes72GjdvJ2v++ZVUpx9913A+sHo9rtNufPn8f3/YGTYjRFca1OilvRe2G7fRfGzemeP39+Xcpi7969vPDCC5sue/r0aU6ePMk73/nOwXNBEHD06FFM0+S5557jB3/wB8faLtzB0N3MYxuGIUqpsb+kPkjHMW1vFY32G4fHcTzoZSuEYG1tbex0xLiRbr1e59SpU6RpyiOPPLJpYw+5/PrgcWq65LrnQIA6eBjV2Qtry2A6yNopAHR+GqO1lD2WBqI+hLGtfYpuDe25pNN7UJZEXjqBmrsLY+mNbJ3CDHIt8/1qINeJcMOQZDpPu1pEXwKv4dOZqZJrZNGqFgIrVJhBVhjRuWsGkhhr1UckGrc+rHYLPYP8SgdVcImKRWSnNXgtms7j9t4zni6SOC7uWh0ByE4XlffQSUw6U8VotsGUyHYL7dho24M0AQNk2MI6+RWssy+jK/NEh76D5Mh7QY4PmFtdkXa1wag+jK/HSXG7Q7fRaLBr164bvg+f+tSn+JEf+ZF1x3769Gn27NnDiRMneOc738nDDz/MoUOHxnq/Ow66VyposCxrkPMaR9uB7saTcbRx+KFDhy4zh2+nbPhqjoTRvrl79uwhDMMtOymJlTeG76tGfMVSIZMzUIK0chdpsYi8eAJdmkN01wAICgt43YsAKK+C0+3nhhVG5zTCaNHdtQurWEI3S4igiSovYHSytEU4VcVtZxCUaCrtDqYt8PdPEzo5nHYLI1X4c9MUall0raTEaQcYUYS2JJ29s0i/hbvcJHFdvLVeE50kIbEVeV8T75lFKYHV6xOc7a+B12yiPJO4WAalsFez4xJxk7icxxCKOF/A7PjoXA4jaqO8HERxln8WMbSXcL/2J6jXP4uauZvwofejZ++56nd4K6A7TrQ66qQYtUdu5aQQQlw2eNd3UtwJ0B030t2zZw9nzw4DjHPnzrFnz+Z3OZ/61Kf4rd/6rcvWBzh48CDveMc7eOmll9660E3TlDiONy1o2K7D4FpKe0cBeOjQoS3ht9087WbL9rdlGMagb+7q6upgCvDLFLYQzcx3q6WJG2XQ0QiEvzRYTCQ1pF5CL+RQ+QphuA+3fg5ljjSKruyCns1Ll/chW+cAMI0Eo/0mlAXprodAm1nHMa3Q3hT0oNupVijUssd2kuCpFmq2QMO2EQx/5NqzU5SWs/1MLBOv0UCmKclsibBYwbm4hOxGRAWXXC8CtlotOnNTGNoj8goIvzNIMchUoWSE2+oSTRdAugg0di8lIQXEc+WsuENIhO8TF0tYaUBqOBi+j3YcZNxALH+L3F/9G1RpjnTPI0T3vw+czc33t6LhzfWkM8ZxUtTr9XVOiiAIuHTpEuVymYbrDfwAACAASURBVEKhsCNOhu2AfjvQfeqpp3jzzTc5efIke/bs4VOf+hR/9Ed/dNly3/zmN6nVajz77LDgplarkcvlcByHlZUVvvSlL/FzP/dz4x0QdyB0+5P/baZ+pDuuxoWu1pq1tTV83+f06dMcPnz4spHmjboeG9ja2hrHjx/HNM3LtnWlijS58i1Er1BBl3Yjm73y3MIcMsz8tNouIDrDCJbOCbxiQpCbxy3OoHQH2V5eZxvDzUPvrr5jz1COMnuZkAEyWEHv20MiprBHnA6pHJ5a3akqpdoaEo0tNF7Qxt9VJdEaOxwetz9TprKSwTGRglx9DeGadGcqpIaNtZhtNyh6eLVmNj9bXKczXUElFkJJDL+D3c4ifNsPCaYdrE5AMFfC8BPwXOx+msOURNMFjCBEhAlmmBCVS5hEJLHE8pskjofRXER01jBPfJG0up/k7u8m3f9t6z772zXS3a6u5KR48cUXMU3zslaQGwfvbmTDmSRJxq4y2w50TdPkk5/8JO95z3tI05SPfOQjPPjgg3zsYx/j6NGjvP/97weyKPeDH/zguu/29ddf58d//McH1+Jzzz235QDcptsee8k7QDc60tVaDzoqeZ6H67o8+uijYw+OjVs23IduH7aWZXH//fdvCvYrwTxOLqH3PIRZuwDW8ETV3hT0oKty8xjNzBIW2DN4cQ/GpoURn4QpUPMPohMDbXmIuAsjrgcpRoCfm4ZgBRE3EZUqMm7T2r8XPw2ZWRlayIxkCPCuV8AL1sgHAe1yHktH1PdNY7YCcu1h68iglMPtV7SRkPc7xHMVYsdDJAkiyKLjTilHrjbcVmduhiCNcBpdUBq73UUqhdHsElbLiDQmqBaw6x2SShmnB+C0kCPOGditLjJRSCCulBEqhE6CjFoktotx6XVYPYHx9T8hnDpIcvi9mNN33xLo7uTURf0p0Pfs2bMO9v1WkO12e12PhX5Z7yiQryU1sd2BtO300v3+7/9+vv/7v3/dc7/yK7+y7u9f+qVfumy9b//2b+eVV14ZezsbNYHuJstrrbl06RInT56kWCzy8MMPk8vleOGFF8a2sIxbNqy1ptlssrq6ihCCBx544IozQlwp0k39N0nMizArMJwiSh0k17qI0MNjbPk+/VjAKUxBLYNuYBbwyKCnXRvRPoOay6PtI0i/ju6ugTDIRSO2s3AY2WppIgQUgybd2QpKKlYsjyQOWej1Y0ilIO8PB8kix6PQCah0Q5qzZdIgoS5yOA2f4oibIfIcckGEHYYErkEx6NLePYtINMaI66MzVSDXyxVrAc3ZKkYSkFttk3oetu8jVHYn0F2YgTQkyjvYfkhSyOE2m2gpiaeKpDLBabaz/g+GQZL3EGmEESQIYaDiNrmLL5GufIOuWSRv7eF8+xk6nd2bdiG70boVxRGbpTQ2awW5sax3MyfF6FRLVzqO7VjGJhVpN0lXiiauN72gtebChQucOnWKSqUyaBy+cflxToKrpRf6KYvjx48PooL+fFfX8r46DdHdXu8EIYmT81CKaRTzoC0IFihHq5TMCPqrR0MASqEHs/low0IAQicoT6LiGnr3LrD3kFw4hhfVUPkZZC9PrIWBaJwbvJedKGylmAl9lqbLtCyDrjBQScLCcgbFwDYpN4YRagqUogAPqO9ZIAljdNDB7oaURtwMWhoIoNBs0qiWsJGs7Z/Dq3cxRn6L/KkC5UYG+7jo0J2awmrW8VpdwnzmehC9isTO3gWIOyhDZjlhy8Rt+KSuTep4pER4rexHIHU8lC2RaYxMUoQFxbRBPqpxd3qCoLHApfx9HBP7SK8BMuPqVkB3XI3jpOjPWHE1J8V2GpjHcTz2BJa3UnccdK+k7XYC6y8/2jh8enqaJ598ctMv70aU62qtWV1d5fjx43iex5EjR8jlcnz5y18e6323inS1fwZ0ryjEmUNHmSc3UDlcaxVmoWEdwEldHH8Ko72M8DOnghYGeT0EYP/WHYC0NwOE8lFuijGtCeTdGPYsLH0LGbVomVVKaRYBR2aecjsDlAaKfhcvjikCy1NF1pw50ighlZKF1QzA7XyOqWZ7sI4ZdSn07GSre3YRhQlWs44SUG4MAWwohRVHVBsRtZkSTiyolV3yqy3scPgZBaUcpVq2f52ZIrGbx1gKMZOUoJjHa9QRWqNsA39qHsPvlXpGMVEhj9tKiMoFUAIlE9xOgBaCpFhC6QhDKQypSYWi0DpJPjjP3XaedPpe2vPfQdMo026310Eml8utg4zruttKT9yqSPd6NI6Top+m6A8Wh2GI67qDwbutelLcKb104Q6E7o2MdKWUrK6usri4yNzc3JaNw/vaTvpiI3RHZ/H1PI+HHnpoMJtBv5ruWt63L9U+NXgcaXPwxQq7BLrbe1ym2z1NNw+yeg9OmOD4LaRWmN1skEq5VUTYt3M50OlZyBDo7lLmgVU1WtrAnjJAHMIzK+hLbUQaIit7EI2s+flyqcRcOxuBiwyTasvH6F0cK8Uiy84CZscntO0BZOuVClO9dVJDUug0cOIEbMHFmVniIKWwtES3kKfYW04JgRtEeEFEDljZXcXSBt1uh1yzg9sdnhOpY1Ou10hdk0ahiBAmTm/bQT5HrrGG0Jq4nCPIl3Dra5n7odOlUynhdFPCcgkZRKRGjONHKMsitF0MnaBMA6FTSEOs81+hvPQqJbdEOvcQ8cF3gTeFUmrgEGg0GiwuLhIEwWWzVlxpSpzbOdLdrraa3UMpxVe/+lU8z1v3OfWXH42K+9ft7d5LF+5A6MLWzWrGhWKappw9e5bTp09j2/ZVG4f3tZ3+C3049mF7/Phx8vn8ID+88XjG1VaRrmoPG5OnSTiE7mjaYGQz2jRpR+doF8DMHSS6JJkzQFs5ZNTL1RZ2I/rvm5tHBFn0HGFjqzpCgqZGaISEc0UMeTeGsrJ0g06J7OFnulQps7eeRdAtr0jVzyI+ZQtS1+DS7Bx5v0liDXeyXqkyXc8i1MC2ma2tYWhNUnKpTxdJPYfSyirtqRlKjWy51DAodQLs3mwWy/tmsFKJ06gjY43Xzn6ADKWRlkOx2SSs5Ok6FlakBimHwLEo1NcAQVApEtsu+bU1pNbIdkxnqoSVasKyi+23EVaK1Y1JXJdUWsioS+rYgEJETeyTn8dc/HvSXJV07lEKe99BoTDP/Pz84Hg3zlrRnxJns0GpWzFTxU4DTUqJEIJdu3at23Z/uvn+3cPnPvc5fvd3f5d2u81P/dRP8dBDD/Gud72Le+7Z2l99tWY3f/AHf8DP/uzPDvy4P/mTP8lHP/pRAP7wD/+Qf/Wv/hUAv/ALv8CHP/zhbR3XHQndrXQ16PYbh1+4cIHdu3fzyCOPcO7cubEtLtsteOh0OrzwwgsUCgUeeeSRG9JgeeMPTn8Cy0LjNLbo9UiQ/iBva6jhBJQ6Gg58qWT4fKo7UO6wBFjuHJ5zJLN/9fKnAJ3UoL/3Or8LGfVyuLkFCLJoOBYtYtklnJumLi1EEgy6i5lq+Lk18h75Xn+GteIU1XZ2Ox8WcwjTZml6lnKzhpEM3QytfInZRs+x4Hns6/luu7NFmgUbKFFqNGlOzTBVzwYHQ8tkqtHGVAotYGlXBTvSFFZrpLZDrhcpO1FMlC+R82v4MyViBG5vxgrQRJag1G6Q5hx8N4eSgmK/FBnolAugIMzZOF2fIA8WmkhKpJaQRCSOC1JjdJYxT30Ode5vSXOzJPOPo3d9FxjWFWetaLfb68p7O50O3W53cNvdL++9WWC8lZH1xmPaON38vffeyw//8A/zYz/2Y3zgAx/g1Vdf5eLFi1tCd5xmNwAf+MAH+OQnP7nuubW1NX75l3+Zr371qwghePLJJ3n/+9+/LdfEWwq6W6UXRhuH7927l2eeeWYAxRtdTNG3mR0/fpwwDHnmmWduaDf7/gk4OjV7eUrS3l2iovaTiyWydQYAZZQxdM9ga5bQfdDKHKoHYC0tVN/DiyBKLhLKEIpgmmWkvgu7vYbJMFeuRya5FGaOwV/eLHROo3WAaxewdJtLC9P4wqbUHboRiiOPk5ELuVasMNfM9mVtrgoYrNp5SvUVCt1hLjewHUpRFrH6Xo69jQYIqO2epmNJnMAhF4TUC2Xmm71qO9dltt5Gak2ac1itlvC6EcVag26uQKFRQwB5P6A5NYUVxTTnptBxSi7Ijt1IEhIjpdzqEhQKpJaN1ppCcwhgv1JCIkhTidPpEBQ8LCVJDI0ZazSK1HZAJFjNc5j+BfSZvyLJz5PMH4W5b7us/Hizxt+vvPIKu3fvRilFu91maWmJTqdzWW/efhHD9cL4VlSjbUeNRoPZ2Vm+8zu/k+/8zu+84rLbbXYzqs9+9rO8+93vHnwX7373u/nMZz7Dhz70obH39Y6E7rjphdHG4fv371/XOHyz5a+mKw2kjUKwVCrx6KOP8vLLL9/w6UP6bSv//u//nlKpxGOPPUakvsVSQ1E31uh6e+l6ecpqD1ZgYrbOYNJFOFPQzQAs3BnoZpGq4cyRhFkVm3RmSeOscEKJIrFahjyExTyGcMgnc+jaRYx42Mhcx8NS3NHOZZZRBFZxVYyd3w26y3JuN81UMhNm+xEaxiDKBXDiIdgDN8d8b2r4M/t2YSQpxW5KwW9SHem/YOjh9xnaNruaTbQtWJyZQytN5BvYaUo3V8TrpSq6uQILjewHKKgUaOdzaAMK7Q7tUplSD6Kltk9jqoI2JE3bQYQB+U4WfbtBl7pnUG53aVfLqAQkgkKr7y2G9nQVoVOsuIvrR3RLOUxlkBopTjdGGSapZSN0hF0/iemfR5/5S9L8PPHcUZg5ekVY5nK5yxqlbzXLsWmal+WLt2NpuxXQ3c7gWLPZ3LI6dKPGbXbzZ3/2Z3zhC1/gvvvu4xOf+AT79u3bdN3z589ftu6VdEdCdytJKQe2lKs1Dodr8/VudEeMenrL5fJlNrPt6Ep5s9HccJIkPP3004PtNHvznAHZvbyAhlHHKswTeR4FFiioEqby0eEqiJGv3RgOHAojB70bBSXyGGQRqeHMEofnqBtN4ukKlkgoUsSKQvCzqFpLC8KR6dujoQNC6AQNGMrH0NPEOUGzsB8tKzjNMxA2abtFyr0fhVQIKqNgFYLZ0AcJJ/bN40QJlU6ITGIq/jBNko/SwUegTIO5ZpOk6LFYLOAGMakQWU7YMukH7h0vz3yvL297pozv2BiJjRdGNCpVyq3M1WFFIc1Snshx6AgDGUQUO9nU8gW/Q72cJ++H1KdLmJFCGBbFdq9VpRS0ZqrINMIMA6xQ0y3kkVqgiHDDiMR2UKYFuoNdP470z6LOfoY0v0A6fRQx/di6c2Or2/2tKso2FjEcP3583QwMhULhipa2W9FLdzspjXq9PjZ0x9H73vc+PvShD+E4Dr/zO7/Dhz/8Yf76r//6hrz3HQndrcDU7XYHM+veddddV2wcDkNIj6vRgbSNsH388cdxXXd7B7LhvTczgo+6HvL5PI888ggvv/zyOrAH0RC6iRrehis6CCnwaRJYBrEl8PQBCiqHpXehuxdRyfBWv91ew+1t3nEtBilVMTzxtXBQskmDDlblAMrbQ14XMBKg9WZWTODMQr/STbro3gCc7uebgUTV0HaOKK+xigcwZQXVPI2MGsT53Tg9N0VgOkyPgLUYx1lqwYSz1WlWw4iq3yUwJPO9HG0iJZVeRGpqhZSCchrSrhZZyecot7soMjhbyfDOpeW5zDcaaFNQL88SGSZRYGAnKY3KNJVW9kOihKCd9/DFFEorzEhRarUHTX5qlQL5IKJWLeJ0Q7TlUepFwLEh6VSKmFGA0w0BQadYRKIh7eKGMbGTQxkWJC3sWou0dRp17j+SFnahqo8jpx7bdo51qyKG/gwMGy1tnueti4rfbs1u+s3RAT760Y8Oeivs2bOHv/mbv1m37jve8Y6xttvXHQndjfJ9n5MnT9JutzFNk2eeeeamDCj0I+MLFy5w8uRJpqamrhu2fW3sNDbq583lcpu6HgBSFRIl2W2zkC5x2uvyJTzSXj5XCo9YZc+HMsU3LkEZ7OJ+7EAiggSXFq6ZXXAaSRoNUwhpPIxapRgObikdEdOmLtoYhX1oe56cKmIqExmvAhrceQiyE1w4s1i99IWWHqoXGcdqjchM8fMpVukAliijkzYibmF7e8DPypZDb4ZSz86WCsFMt53NBWfDaqGI77lMt30ansvu3kwWvmVR7fmG7TTB0xKPhFq1wprnMtPMjjmRgmKnZ60DWo7BfLNB6tpcLJQwVAZzUyka5SpTzRoQkEhJK+ey6lUx0ghTCSqtbJJNO45YqxRxY81atYjnd0mcHOUegEPXopsrYoUdvCDMYF6sIAGZ+HhhQtfNk5oWImlh13yS1in04mfYj4duKPT0E9d8rm82AwMMfbPtdptWq7VuosjXX3/9snzxzdJ2oFuv129os5sLFy4M2kQ+//zzPPDAAwC85z3v4ed//uep9Sof//Iv/5KPf/zj4x4ScIdCt3+SbWwc/uCDD/LCCy/clA73Wmvq9TqLi1lU+cQTT4wF23GtNqP54j5sXddd5+ftSwgxiHTC+AJ9T5hlTJGmmZPANsoESQYRy6yQJJeGj9PssR9BkG9BXrLW3UPFsijEGiNNSMMs5yutKZI0y3EKmUf2O98Ik7gPUCBNV1GiS9PoItxpcObIpyVMZSBDA3SKNofpC+HMDWFsz6KSFRCCiDYhTcgrbHkAU3hYUQkRNzGtEsTZyS69/ThBltpIzBy7Oq1s5mNX0sk5nLJmmG63Wcvn2dvI1lnzclT8DMZOHFKwbCyZsjQzTdN2mGs0II4ITJNqr4Tb0IrQhLlmk04+x0rOIx9rUgQGmka5SrlVA0IiQ9J1bFZyc5hBGwybSi/6dkOoFQtYSrBaKZL3u0SuS6kXxfv5ApHt4IRt3ChBCUGjNIVAY0Yd7CSh4+WzasG4xZRuoxf/AnXxs6S5XYjyw5jVJ29IsLGZb3ZlZYV6vc7c3NwgKu43vbEsax2Ib9SMFdvtu3Ali9ioxml28xu/8Rs8//zzmKZJtVrlD/7gDwCoVqv84i/+Ik899RQAH/vYx9YNcI61/W0tfZuo3W7z+uuvkyTJusbhMIxGt/OlXy2X2i8NLhaLTE1NDX71rqa+p3acfZFSsra2xuLiIrZtc+TIkS17MPTfV0pJN1khi800UloDq5gQQxucGMnhJomm7wMr5Et0VS+9IE3qdoO6DQVjDyIyKSQmUkno9Cq07GnSnlXMtOeIet3GTGuGOO1H23nSNINcw1hDmxIxNUVeV7BTgdYGhkjRI/0gMHPQ+1M68xnwhSA2IUzPQl5jGXdjahvTKiPiBpqhS8VwFtDdU9kfzjxz3aw8OXFNTNPl4tQ8Rb9Ox7GphNkP0VKxxFyvD4QTdSmQgqm5ODNL1/aYbqxhpV3ajsNMKwOnpRIMKSjEbeqlPLV8jmJ3mOP38xXK7QzAXcskMjXL1RmcbpvY9pjq5YcV0CqVkRrWTEm+G5AYgmIPwK1CicS08PwGdqpIpaBZKGEgMCMfK0louR7CMJBpB8M/he6cI7n0n0i9OUTxQazqk0h54y7vNE2xLGudVauvvqVtsz4LozD2PG9bKZGb1dYRrt7s5uMf//iWEexHPvIRPvKRj4y9rY26I6ELcNddd23qjevbxsatwd6qkblSigsXLnD69OlBabDWmtdee23sfexHr1c7cWq1Gmtra0RRdNWGN6Pva5omZ+0ajeo800keMzUw0gKpapPqYRogUcPHUeLT57ESI1MEGcPcZkJEYDRpGeCa8yhvD6Ukh1QGOpIIFIxC3chDD7paDCvgTGuWKLmEFtAxExpmA22WKIkZrEQhkxw67aBH0hejMBZmEdIaCEFquYTxeciBZdyDlYKZTqHjOjoeNuHRhjOIpgM1Ra5njUu8IiWZo10uY3dWcPXw1L9YKrOrP2CWhFhpF20qFgvTtC2H3fUaXhzSzBWZ6UeuaYyjUvJpRK1UZM1zqbSHfY67dp5y0AJCfMchlQnLU9PkOi0CN89UqzddPYJWsYJAUDclXhCCTim2fTTQKJbQhkXOr2OmisSQ1IsFSARe1MFME1o5DykkRtLF7JxDB+eJlz9PmptF5u/HrBzFNK+vJ8GVzuPNLG39Ae0+jJeXlwelvX1L28Ym6Rt1s6bqudW6I6FbLBa3vLW/1k5jfehuhO1oaXAcxzfMYgZZHurYsWMYhkG1WmXfvn1XBS6sr0pr6mVimXDBbmIIizTnUkqqVBILUxhEwTIha715Fw2E1ctbCpOwF5EKTLD6k0lKwnTY/DxIaygR07W6GNIjtacohB4laSOTPCr18f0V+r9ZURzQv046nRCzn/ITOdANhKEJTIumcQFsi7x8ADuKkIEBKkJF/UE3UMkIjEdaSqaWTajPZgA278dOYozQRic+OhxOJS/E8LuS7hxpkFXXhcUZpJQEzixWe4m5YDiY2sxXmG5n+WxTaxb8GsqCC6UZGpbJ3jQmF4esFqeo9lMVSUQhlnjE1MplVl2b6Xav4g6IpEk56AAhbSeHFoqVyjS5TpOOV2Cq1/hdCUGzWERikJgWVtTFUDFO4KMRrJTLSGlRaDcwVEpsGtSKeSxtYQU+hkpo51ykcDDjLqKzSBpcJFr9IoFXRebuwS4/jWmtT1eNo+0O3I32WRi1tPVLoDda2gzDuCxFsd2BtBvpXriZuiOheyWZpnlNncb6TW9Onz7N7Ozspn0YtlORBltDt9FocOzYMaSUgxkhvvWtb227mU5Xt4joRQ+iSKeXb01NmzNmHVzQaoYpz6OsJFaq6SRZHtSWVboqy8na5jRJ77ErqwQqg45rTNNVWRTpyCkCXQcJvqNoyRW0ZWIHu6mYLkbcJklqmOaw2Y3lhPTNIUHYwOiBOQg6SAsQEJmCllgFB3LyEHYYYEZNJJI06TVblx7pKIzTobc3NRSt9BK4YNl3Y8UxZtRCpQlO2i9aEOgRbzGmRxqeIwXiyl60CrGYx+rUmR61qpkVZDz8kdrtN0lsybnSLF1D4kYOuThksVRm9yBSjpgOFA4JtXKZNddhpp2lMRIpQQgKYRfosporIAUsF6coBm1812PK7zswDBrFHFLYRFaMGUe4SYyddFCGYK1YxBAmhU4bQwVEpkXbsTG1jR34SKVoOxZCCKyog+zGqGCJbu3LaGcK6d2FWz6KaY+Xj+ynF65XUspBlDuqJEkGUXG/L2+n08GyLIIgWNelbbOIu9FobKsq7FbqjoTu1ZrebDcaXVxcZGVlhdnZWZ566qktR2S3O0ixMeruw1YIwb333rsuN3a1edJG1Y90fT28rbbxBtAN2zEU+ss6rDk+a8AU83TUAtOJB9rCCH1S3UGK4fEa0snCM8AQw7sJS+YIehCLOxKjAEIK7GKZJZ1BL6fvxk0Vdhwh0oQoXertQx5D9iI/JZDW0NbWCVcw+pFx3KRjNcACV+7DTopYcYAQNirMolTDmiNJewAVDkk09AYnuk0oauCANPaStBzKlkQKczAwiMyRjkTDWseoZJUQiMsH0KmLSQ4z7OD05osDyGsXTRMJuLJIqXuRxBacKc0TSoVvOuSTkAvFEnt6qQORJsx0E0yhWKtUadg20730RGgaeDrBjrMUz1K5hJUqlgpTlIIWvpuj0vWBgMgwaecstHSwkhgzScmHEZbqooRkuVRAakGp62OokNByCC2JgYkV+Uit6Vo5tNbYcYAOV0ijVdrNlxFOGeHsxs4/ipvbv+U5d7MtY6ZpXmZpO3HiBK7r4jj/P3fvHmpbdpZ9/sYY8z7XZa99O/vsU3XOqapTlVRM5WJsUxVoyZcKpEUpFWIiNlGDYBCkuxHUQEBESKeiYncEkRZLjITPlIpQ/tHkg4gJtEYq0ZTGpEzO/brPvq77mtcxRv8x57rsyrnsnYvJcUDBPLPmGnOuudd85jue93mf12c8HnP9+nUmkwnGmJlLm+u6DAYDer3e9y3oigo4hLWVDeADCbr3GkelF4wx3Lx5k+3tbVZWVo5senOcMY1IB4MBFy5cwFrLuXPn7tzF9y590u45r9md7dPGQL3680OPsi5ssHIO5CUFmcy55eXEYplhENDSyygdYrMlpDrMBWs7TxLler7f9R1mswoxN9SRDntyG1xosIEofcJSoaykLK5U15A3cMMKdB3Zwchp1OqDrIsJrGBUbCOdqlsvZolQnSY0lQ0lNegqdx1T1CoLZ4VySosIRWn3oJHTB5RzEs9/BKcoqv5sWXUtwl3DzBQYAl0eYPUIzQFFfBoTbOASo0qNTa7OjvPLycxTYlkuodNraE+w234YB8PEy4jyhP04ZqNOjhUYlicDpLDstTtM/JjWuI9X5kxcl6U0xakr+rY7S7has+ut0JgMyByfVjoGMhLlkfqKXPh4pkAaaKUZymiMkOy0QhwLzSRBmZTMi0idykPDLSZIC4kTg7C4eYJNC3TeZzL6DyZOhAxO4gRPEEZPHgLZ74VOV2tNGIZ0Op1DkjZr7cyl7eLFi3zsYx/jypUrPPvss7zhDW/gx3/8x/mpn/qpu857P7Ob3//93+dP/uRPcByHtbU1/vRP/5QzZ84A1bP31FNPAXD69Gn+9m//9r7fw1bFAFYI4QHL/+VA13XduzdupALbGzducP36ddbX12c86ncacKFaMp0/fx7HcTh37tw9if7jNrI0xtC3c9Ad5QOoA9NSVWBpARvMqZYJFQAIJON6e6hShirFLoM0LZZMTEM3EcWYzNTLcyvIamoBC2aBQkjtfKmfM49gS5GSOgOGDgRijdKs0dQRRTLGEznW5kgVQx09+84KWXmr3l4lq2kNQYBWfcYODK3AaIXjrRGWClfr6XumqqYzFei67knyei4pm+T6NjlgXYFSbTz/LF5pwcpZAlD5m5RFXWQiQ8riNtiSjB7SP4lx1nBlC2kkdnyx0otIf6Y1FgIiEaGz9/wCnwAAIABJREFU6xgXJvETLAlN4VncfIhxAlRd5pwoSWdcvTj2m0v0/ICVyZhWWjLyI1YmlUcEwE5rCaULsmAVPxmAcmhkKZAxcgKMshx4Ea7WGAFLSYq0FiMk++0lhM5opgnKGJKgQV5XLKp8DBZyNwZLZS5kcoxOSCeXSft/j/BWUe7DxM23fF8VRyx2LF5fX+ell17iR37kR/i7v/s7Xn311Xs+R0cxu3nrW9/Kl770JaIo4o/+6I/49V//dV588UWgKhp55ZVXjvwdhBA+8G7g9YALNB5I0L3XMv9uke4i2J44cWIW2V67du3YHYHvp70dDodcvHiRwWDA5ubmkfSDSqkjc9FSSpIsoV/uggJhFaYGV4+AjLqqiAaTGiBj2oypeMdItBlSgV2DNkOqhJpvGuy5I/ZcaHhLTIwmHEk6KkbIAbnp49gWZR2RBrJDWpufu6JBNi0bJpiBsUCR0MVKzZ7MsWuKsQpomXWk9nHoUOruYdWCmGfaPWeFxFRgGDhrpHIX42omJsTKMSJbQkwU7mRM4EiEMJR6HqFLZwmKUT3XCTKzQwkkro+1msA7ha/dQ5WJylvH5Nfrzy9XAAykZoRw29jGEp5aRhoXO7mAAHId4E4pDMCKElPcxigwS68jsgarHcgPaJr5Y5e5Pht1Q8/9uEU39GknkpVkTC9ssTwe1Aq/hP1GG2lyEn8FNx/hYImKnKjIGfkxjtYcRE0crSmVpTPuVyXRQrDfWMGxBWE6wbGaUdCEui7PKRPAkLsRAlC6QOgEbUvyfIti/CWiyGOSPITnv43Av3Or8u/0OK70M4oi3va2t93zmKOY3fy3//bfZttPP/00n/rUp4555YfGTwM/QAW4u8CFBxJ04e6mN6/ldLXW3Lhxgxs3brCxscHb3/72Q2/P43abuFu5LlT64QsXLlAUBefOnWMwGBz5RzNtcX2/kec5BwcHXBncYOuhDidMSFs7GDsktT0CGuR1rzOfmEkNhJ4IGE8Bkjmoucz5XLkgo0pHGaYF4yWDJyL2GRGYEyyNQ0Th4rppxfPWlW6eaJHZ6lyBaDOuaYpALDOmTsyJJRKnhwUSpemrXfAgMBtEJsArT6HLfXKz0FWY+T0RzO9l4HZIdIL1S7xohYndJTFNvLSJLHIcPKTMSdKdmWnXYvzjOmtk5U0SehRuh5wernuC0EYIo5lqn4WKKtka4HgnKcqKD870DlY6EMe4coVRN2VJ9hEmRXgn0DVQWwTaDKrknwNO9ERVKKICbN5lKS9mLm2O12Gz7ubRjZc48B0yFbM8HrPbaLE2qekXUvp+AyUMo7CBzBOissDXJb7O6YUtwjKlG3dQuiSXhuVkLlHbjjt4xhDmGa5JGIZNhC0wAryywGAp3QArShwrkDrFkQZbXqC3dxmcEOmuEHjniMM3ftci4KP2R5sWaBxlHNXsZjpeeOEFfvRHf3T27zRN+aEf+iEcx+HDH/4wP/mTP3m/U14EPmOtnWVyH1jQvduYqhemRuU3b968I9guHn+UBpKLx7922TMej7lw4QJZlvHYY4/N+KdpZ9SjjPsl0oqimDmmxXEMZwOuqQE31IRSrbIlQZolzuolfBPimAyQM77VsCC5Yn5NxUKRQaLntEzQ8hnVyoicKtmTypx+6JE0DeCxaiI8fQZPFxi7YJY+N3tECDXb7zBPzHmiSV6DtFIxe2oPXAjNCSSaRrmG1AWZ2ak/IWeUA0Bp5n8zW7mpY6VBNmPGZgB4MFqm5XmQjzAmQevdioK2kGYHiBorhApB9yjECOk0yfQO0mkRsQK6QAgPa/NDBRmOe5K8rCLb0o5RrTEjIfHUaRwisAlCD3H8hyiKae86l0LvYE0CApzWWbAaWaaQD3Gz+feL3VX8pIq2k8YKyvXpxorWZMBOo8mJmivWIiX1G2SOYax8jM5pZWMcY3B1wUHcIs7G7DfbuFqggeV0XqSx3WihrCHKDIEZMQqbODqjkBZfg8Fi3ACLRqFwyjG5UpTZNUbZDUbjf0Q4LVzvFI3gKQJ3zr1+u+OokrF+v/9NBRvfifGpT32KL33pS3z+85+f7bt69SqnTp3i0qVLvOtd7+Kpp57iscceu+sc1tovAAghfhn4tLW2+8CC7t0iXSEEg8GAf/qnf+LkyZN3Bdvp+HbsHadEfpIknDt37lBl3HTuo0bRd0uklWXJ1atXuX37NqdPn+bpp5/mxo0b3PauzY7RdQxnJPSE5kBU9ELL+hRJh5NOA2MsgW2QMJ7xuSBmlIPVgtKvwFWiZvsVDqN6W6JI1bjeluyqLkYZBAJpJA2zQVO7GF0irYuhILVzs5qcyWxb23lhhmV+z5QKGLDNUEGTE0xsSls38Y1HWe6ALXBFm6KO2gXuTOIGkNsFwx9X0PMrNUOD0yiT4WiD1ZrSVFysMYq02J55+mT5GBQYcnJHkYptUC6RPI0QBkGBLYeUZsFFzWkjihFgMQJG5hr44MhTeCJEsALFfhUp17SFkA3y4hbTUjw3fhisRhmD0CnlAlXhOS1kbb9p4g06OAykQ8yAUdihldT96XRG6fiMgoDcCZBG0k6qbhvtZMhe3GIpHbPXqPwxjLSsTOoW9ELQizsYWSK1oJGmDL2YwOSkUiILgZYGHB9s9fJxi4TCV5hyn7Q8IMkugLuE62zS8h4jdNa/rbLkO3UfvtP4TpvdAHz2s5/lox/9KJ///OcPFVpNj3300Ud55zvfyZe//OV7gq4QYoWqXOdXgf9PCJE8sKD72lGW5Syy1VrzzDPPHLlV+nGLKaaeD5PJZBbZ3unH9e00stRac+3atdlyaNELWEpJz5tHekNRa0kt9OtklmsdBkwgEty2JRORAR6rZYfIQmwMJklJ3AOQ4OuYtDa8adKmTwUqMW169XaTJfqiesAbLNGtueAWS/Rll75MMNJl6E8QJmJNd1BGE+gMQ0Zag73EI2FKIUgmzOmElLlOtiRDC82B0yMS6wwDQWTWaZVtvDKk0Pt4apWJrX0lRKdK+FGBMQv3KBNDCjkECaG/gTAnCbSLhyItajkabbSqo0ArmGQ7SKe6sROdYpwKwMPocYQtUUWCLYbkxVxaZhd+B1IGTMrroMBxN3CEixAnsdkOyl1C1xGwUisURQUEBSD9kwj/IZRRCKMp8zpSporqbbmN74J1TxILiY0aiGwX5bVxsupaHAtIwSQIGLoBWIe1SRdlLZ10wkHcpp0MOYgbCFwKUc7oi1JKhvESpSjJS4coTxm5IVGZkzgeQhtKF6SSZMoliVcY+y6OFfjWA3PAQPdwtUssT7Divh4lvnvGOMcpjDiK2c2Xv/xlPvShD/GZz3yG9fX12f5ut0sURfi+z97eHv/wD/8wcx+7x/hBqkTaGvC/Av0HFnSnIDcF21u3brG5ucnb3/52vvjFLx65kuU4oJskCb1ej16vx+te9zpWV1fv+Sb/VkB3MeG3ubnJM888802cmZUw8mvO1Pokooqm27ZBT47q7Zg9WQFIw4RMakWDI32uyQpEW2XMMJKsmwAnN3i5g/VS1ALrpBZ8G9QCp6oWyoAd5ttTjthKKHC47VUguKLXsKaB6Y1ZjduM7C0smkgsM6pBPaA9U1i4BCRMAVQyFhUwT2SC9iSZN0bYkI5t4JYeQo+RIoBaceGyjJYVNeGLDpmtjXJwSdjHSs1YgiuW0O4SDdNEGQ9bZBibErgnSWvzIEGIVnOVxiDZQ/lpxdGyjnIs2WBIM/Ip9KKMb/4CkSomKW9WtEK0jpYKpU5j892KgpneS2+TvKzOmyMQqo10TuCIEGUkZVY5rhkrgHTWdskJN8HmiPAstugRqABd7OACnpAYM6ZwPbpeRCldOpN9BNDMEgahTydLGYQNcuVSolmvAThTLpOgiTaQehK3yMg9l7A0XGufYeA0KZ0MI3L8zMOTBZ5QaHdCUywxMjfp6l2W5VlWxaPfFfe/4ziMHcXs5td+7dcYjUb89E//NDCXhr366qt86EMfmqmHPvzhDx+l28Rl4F+A/wFsAeEDC7plWXL58mW2trY4derUrAXPccdRQDdJEi5dusRwOKTRaHDy5MlDpY13G8eVgY1GI77whS/ck4MGGAfprGVOw0YktYdCgA/TSHcBOMXC8r0/HEAdFLiRh5YJWzKhGYYMfQXEPFRGeOYhfFOiF7jgjAVvgYXtdHG/SWZ64VzMOdBSaPruGNbAGpc+LZZ1hNU+gYXM9nBECDXoBrQp6iRaxDIDqgg7pE0ypT6Ex57YBb+6F4F1ifVDeNpi9PxvqkQw45UDtcq4jow9sURKvzZ97yOUwDiK2G6gbIzLCoU+wHOWZwoKT65i/Jp7tZJSdikpoAX7qYtylvGsj2cVpblRecoLj7zcmV2PUAGprhJybniCHI3nPYrNe2gzp2Bc9yGysq6cE37Vsy5cRpqIfFLi673qLysCdNnFTj0v/NPkZoATnsWWEyQl1OqQZeNTFAegFEmwQq4C/Lpdk1+mJEqwnCWMvYjUi8AaWkmPCBi5HrnrkXpNrmycxbgxiRwSmpihGOG6PiYXDG2C0R59p4s/8XDcnK74D26K67xO/DChd/9uKsfxuT5uNdr9zG4++9nP3vFz73jHO/jKV75y5PMAWGsvABeEEP+vtZXX6gMLultbW0gpv2WwnY57gW6aply6dIl+v89jjz3GG97wBi5fvnys6PUoPdW2tra4dOkSxhieeeaZ+2Zi+/78wXQWos/FBFa+kCwbmYTZYU0FlGChL6rlt7CCsTs1/ZbcVAOsY/GsQ0FJYFdYL0OENYRakpcTxn4VxTnGYyyGIEBqRVJzvpSCoVPzrkYwFDV3bGAoBhhh2RNjhk5JJkqkabJW+gT2FMIkh5J9dsFEvYqAq7lClshFFVk2WGYkDkidCZ4TkYkElbVZlm2M1ih8NBnlQq83R4RgpzK6lQqMBRRSMGQLHFC2jbUOnjmFLntV1436NofqBImpwFMXHiqaAJacCWkZYUUTUg+3dPC9A6QAKVpkek5HGHTlJwz44SkK28cTZ5FFQa7nvLHrrpOVNyudNBYbpeQyxJPLOATo7BpYkLJVR8ol2gxwvIcpyj3c8DTCGLQZMS059EWAyG+DABOsIeQSrXIPSHCsxtEZYZmQuS5dNyZEIazh2tob2fcSMjGkaSOGMmVdr4Eq0QEkoiS1KSfsJsYrECUMxJBh0Wc/+Xuiry4TEMzKge9U3ntcs5vvRiLtOzWEENJaOxRCKGutfmBB9/Tp03cFtEW/2fuNO3WPSNOUy5cv0+v1ePTRR3nyyScPWUceFXTvdey088SlS5dYXl7mB3/wB/n3f//3I0lfbnoCM15iJfSrCinrkYmccc3tYmEgpuAHY6cC1ND6JLICnRYxvfr4jm1wICsQXbLNGS3Rtg12ZY9EaBLH5arsAoLmsIMnBc4og9zgtSS5SGmJNj1RAUVbLtOtt/00JI2qF4UcOZSt6u8W6XimI/ZEwLZXUQCuddFoOvokkZEYW9Tutfo1nO88kpaLcjKaZCRoX5NZya57AMZhyZzAWAiMS24GTBbKqDXzxJ4jYqgN4H3ZocsOKHDdEMcYIvsQ6IzSzCN8XQYov7aKlGskbhWFioalRJPjIYsOIpE4ssRzE0zRxogpsEpy20PbCaUdE/inSLTElw/jaIdiwfxHiAjBBGtzNCWJvQqewJObOKKJKPawZRflrFbObFiy8haOd4q8zPDcU0jrUS50ikY1yOqqQeO18Zw1Yj1Bk+Pis5Rn4EW8evJptr2M2CwxECMi69K2IWNZ4FqXbfeAlo4QhIyNwLcBiZ/h2xV6Xp92FCI7krPJI9hh1VTzteW9i8VKR/Gj7vf7nD599xLm7/WYlv9Sv64fWNC915hGr8d1tc+yjEuXLtHtdnn00Ud5/etff8f2z0dVJNyJXpi237lw4QLtdntmhm6MOTKYX/YT9h3FVVvgo8hFzLpZxgM6poUsCwb0Kw1s6pI2KnBq2mjG/4Y2pFfTAv4hTnaBX2T+0pILFEVZaoauhg6sm1Vuyy4N0yQuIpp4GJsgFqLTKIhIa+WCss4M4ExiYNrKa8RsOzZNuk6XPTlmSS/RU0OkiVkrl1CURCakJJ0pLCoVxpxzzRZUErPoXwqMcNkW1TK/rTcQZATGQRhNYqceDpLEzgFuMeL2aTOSt0kYETqrTGxK027ilZJczZOBi6/wQJ5gbKtoWHlQeEM0Fk0H121jSx9hepR5hBNVQG+Nx6TcBqFJzS6BOkEqMlyxhi/aFHkXq0UlfxOmPqEF6THS10CBclbx5RJKe5T5Lp67TjbTGO/iOqsUdojjreLKNqUZYhGVabrTIa0BWDgBjrNGMRhzdv2nOV00oYCCkgM5YU+NGYmUm6rPjhrR0isUaGLrUEjNBI0Wki2GbOoVCqEZC/hy/DX+J/fNnF6wg1zsWNHtdplMJnzxi1/8Jgey1zbV7PV6vOlNb+L7dQgh1oDHrbX/CA8w6B6lKu2ooGuM4T/+4z84ODjgkUceuSPYTse3o0jY39/nwoULRFHEm9/85kPtd47ary1Dc1AnxTo2pCdrHg+X83USbXkoOFhqEVvJWqFpFC6eMjhWISxYAWahjXqxUDaQLkSP44XWPMMFICui+WenFMVIFNxwJ6SyAASxlsT2BE0jMRg865OLDO3Pz+U0FgB+Ib0wTsYzAM6zHCIw0lIqybaqgGlZr2NJiY3CMZIx1ZI9oEkiatlYKRnVYGitmCXpALTUjMQQFLRYZ2ibtE2D0PgUtou2OR4NEqYALEgXgB0kVhgGok/TO8HEA9cu0TRLaFEiyxBtUzLbn33ClU0KM/WdiJnIHXCrUme/0UaaDrYcIoyDFhXPWqYBaVC9EHLTp5SC0huDiWg4mxiTIYoMa3OKhcSdq1qVcgKQfgOUi+M8jC66eGqpoiqA0gyre8sA6cX46iRaJyA8sDnKXSErbzMevhml5s0uXRxOmBYnzHxZb7GMydlXY/bUiInIua66JMLQMitMhCWwPl0nRVnBZ8J/4X9Jf4imrfr9LXas8H1/5sJXluUdm2oGQcCLL77IjRs3eNOb3nQkSuJ+vgtZlvFzP/dz/PM//zMrKyu8+OKLnD17FqiMzV944QWUUvzBH/wB73nPe+55LiGEqH0XNoDfEEL8X9bazz2woHuvMTUyv9/I85zLly8zmUxoNpv3bWQJx1M7TIG02+1y4cIFPM+7Y/ud44ybYoitL7GFO4tWy0k6cxZrtJocMGAsDJ7vcMWrrnfF+oxY4YR1yFGsmlVyEoa1rldqZuqHwLoM6v1+4cw431gHjGvlRMtEM9Bv2YhB7STW0iEDlTAGEh0y9FIgYC1fptRjlk0IlIxqnte1LmNVnVdaSdmogdlCHsyX/b2iN+Omx3pC4leQuKyX6YqAtolwdERMQGr7iNSjbFQvhQZLDEUFmp4NGE1lalYwEn201BzIPg27xEgUuKaNb1cITYo2Q1wixlRRskPEmDk1kdWURyEyMgeGHICCtn0EKzROmWH1kMTMk2m2KngDIJRrjOxtkOB4IXglAQ+hjMVXhqxOugmzTFmrKIzV9IvbCKcAFyIeRgiDMhFWJ2Tl3H3NdTokukoEOm6DUhS46jTopEry1f/PIkjMNoYUXEmkHsfYnKb/P9M198+bCAQNfBra54yeR7AaQ1dUUfGeHCFtwE3Vo6lDPud/nXdlTxLbwybriwDqOA7tdvuQLMxaS5IkvPnNb+aVV17hL/7iL/jEJz7BmTNn+Ju/+Zs7Xt9RfBdeeOEFOp0OFy5c4NOf/jS/8Ru/wYsvvsjXvvY1Pv3pT/PVr36VW7du8e53v5tvfOMb98wn2XkU9Srw34H/XQjx7H9J0L0fMOZ5zpUrV9jb2+PMmTO0223W148m5D5OpNvv95lMJly5coXXv/7139QW+1sZN8Rc/L8YGVu3TpABw2lHCAujoKKTPCs5IMEK6AHXaj53zTQ5IGGlUDTHmmbLQ9uMwDrcVlWUFxYumVvNHduA8UxVMKcoYhtUumAgsgGD2X6fYb2tpMduZ0KXlBN6iT2hWTEBjdJDi4TMjghsRK92HmvZNoOaX45Ng3FQKzO0R+LVfKqGLl2shJ6YMKEkd3IwLlHmsyTaKFsc4nwjWuR1FN9kZaY99m3MqAbmUmh2ZY/Sqe7lkg5wzSkcq1HWIacCqpjVWZmzwmfEvFAjVQmTmuZp2w00GZ5xUGVJYrdrwkaQLRSQ+KLN2N5mRIKvOiSqR+Cu49kAaUGXQ0CjzDLaq6Nw4zMWtxGidprLl1BOjIfEQZPoBWN3GZGZXXLAdVbIGRA4D6FslVCdRsCOaJDom0TuGXz5epS6xLc6FJJV22C1bAAnZvsTCg7kiAM5IdbfDLr3AjQhBFEU8b73vY+/+qu/4o//+I95+OGH7/lsHsV34aWXXuK3fuu3AHjve9/Lr/zKr2Ct5aWXXuJnfuZn8H2fRx55hHPnzvHyyy/zzDPP3Pf7W2tLIcRFoA985IEF3W/FU3daSruzs8OZM2d4+umnkVKyvb19x5Y9dxpHiXSHwyEXLlzAGIPv+7z1rW+9/xc64rgh5kvIg3QIMWBhWEezvlX0alBctgEHqtpesRFbdRS7ZH0GNTDHeOyKhB1XY5XDRZkDguVeiYnarCufyHeQxmcsxpiFDg6LtESx0KUhP7S9eMxC8QcGLS07MsEKj12VAx6n8gY+PoG1uFYh7RAjDAEB41oO1xQtshooO6JDV1ZRa5iHJH4FxjJXjFo5I5EjjEAiCewybe1jEPjEZIxnqwaAsN4HlRqiXye5AhvTU/tVlG0FSng4dpmmDpBW4ZiQkoRQdBiwXc/VYcTc9GcsDijJQUGs1khoEdMkKF1yu185fREwWXCOoy6hThmgZEiPHaQKcLIY6Qhc0aa0fSK3w8RU9IorlsjCPoaq0MLkEYgGqvRwjEJ7+7Ubp8QIg7E5E7tDKE+QmG08bxWXAGklttSsRc8yGRffFX+FEJdT5s5Sr6P6LkClXphKxu51nUfxXVg8Zhph7+/vc/PmTZ5++ulDn7158+Y9r2uqVhBC/DjwvwF/C/yfDyzo3mu8tntEURRcvXqV7e1tzpw5c6i6a3r8USmDex079WDI85xz587R6XT4x3/8x2/vyywMYwxXRBcUSG1JomqN2sGnWyfIVmzIrRpcm3gczMxv5j/GRd1usaDDTeUcFE0roCczemS00IyFQdiQZeHiDGPW4xjQxDYgJadbR+COlTOK4rXbXTmlEMQdt7GCbXdcgbaFyHqkxKyagByPtlklE+ND+t/FETnRTD/cUm0O6qg1yiLG4ZgxmiwpZ/RFmC1X3RfYoLCjmQk8HOa8AyLSGoxbrNAT+xQCjJBV0k4IVNLAc1wis05uBwg5f4E3WWFQUxMecUU/CEuffTK3QUqBZzu07DLWTijLHp4IZuoKi5i9DAwlFkkadEmBiE0yFK7ZpCwPDnldhHKDSVCd13glOT4GH5EF2InECSYoD7CKTPeqTh62h1KbDM0Wpxs/ipIBWqffE1vHo3TbBphMJoRh+F2+ouMPa+30gSqA37TW/hP8F06kTfuZLfoWvBZsF48/jjHNa5cwk8mEixcvMplMOHfu3CHDZTia7GX6ne4kdZtqeb92/TLizQEn8Uj7ffSKw9jmNO0cdL1Dut35yBay8IMF+uGgphmkhlFYWf3F1qVXS8uWrU9fVsC9aiN21QRaCmEUt2UKuDysOwgKWhoCKxipMSMmdEyDXVUtnTumyW5dYtspG+y7w9n+/fqYZROzV+t8l0xMr96eADtOXTRhQqS1dOw6vgFDgbIKjWYo56CZyTkX7Pku04LgdrjEfs3HitJhu+Z8/aFLGQpa+QqRdTFOjrQSg11QSYBeiNYjG5PVPDbaYyuqJXI2wjWa2GwibfEaBUSTtL7nTVYY1teiRcmB2EGLEhxYMm1cGghd4FjJqE4UKnwKd05HWKEYsFtH0Ksk5Pj2YYxOKBaKViJ1ouKNARkabFhQYrC2hcoaFGaCkCVoycjdxsk3SMcRTmNybIvF78Q4qk53SrEdRR56FN+F6TEPPfQQZVnS7/dZWVk5smfD4hBC/AhwyVr7Pxb3P7CgC3c3vZFSsrOzc0ffgjuN44Lu9NjF4olz587dsSz4XlaQd5p7EXSttezu7nLx4kU6nQ6ttz7JV9RNKOGUjtnKHHxilgloS59QGKQQrBIxEBn9GoiFhb36QY+sQ7fmM5eNP1NCrGifXW8KtAHjOppsW5/+lMO18+jNX/jpSKG4Kkeg4OGyyXWlcG2LlmnQxsdB4xqJkhItzCH5mWMXVhwL84fWo1dDZdMEjGrgX7Ixt1WPCSXrZZsdZ4IwIZumjWtLIqOxVtOteWHXuvTqhB0WhnIOWCJa4HnDiK7Tp+tkZAPBJM4R2qc5CLAOhCpESMuwTmSJOgE3HQtfg9g2OVC7jFRC23ToyxGxWaapQ3IBjg0oSTEL9EzMMv1azhbYJj1Z94QTFRWiWMe3Hr6WDKgq3XzajFkoOyYnZUAqBjTcDYbsEbGBq11ykpkkrLLerOZX0iUN96ubg0OTDdCGVvqWWb+y4XCItZaiKA4VNBx1+f+tjOOaph8lqDmK78Jzzz3HJz/5SZ555hn++q//mne9610IIXjuuef42Z/9WX71V3+VW7ducf78eX74h3/4fqdUwK8IIW4AXwVuAP91DG+gejteu3aN69evEwTBkavVjqtIWJSYvbZ44k5zHwd0p8dO5WVxHPOWt7yFMAz5a7M9t2qsT5cBtzBsmRKBJRKSVHs0CXGwtAqfZQ1+w0GLktBKrsgeVoAd5lCXrIfSq2c7rMnVCxxuthDlTRakZQMx1y336wi5EJabTspIFmAhli6JiGkkmlR5rJQrGJEzkfPPDuU8MpuCLECyQCcs8sjTUmgrQRvBTbcC6Y2yw1Boooll2VtCizEJYyIT0atBMzYxQzWlPhz6tRQjM832AAAgAElEQVQNC7bOd1olMA2PnbqnW9hz0V5ElCs8qzBhVenn64hJPDUdmlff1dMBMJYJHg32VZVo65SnKASENqAwwyrhVg8Pf1YE0mKVfi0fy/AwjsE4PkEZE6rKfS2zXWJWZgAscZjQw6IZc0DsnGAghjjENPUyBSVKN9CMKmOg+iojVhiyxcPeM6yvPVxZtAC3b98mTVM6nc4dZVuLQByG4XfEX+Goke5xovCj+C784i/+Ih/4wAdmroGf/vSnAfiBH/gB3ve+9/GGN7wBx3H4wz/8w6Oc9yHgFvBDwJuBIWDFfbShRy+A/h6MPM+x1s4cuW7dusWpU6dYWlri2rVrRxZMX7t2DSHEIZL9TqMoCi5fvsyVK1d44xvfyMmTJ+/7A3vllVd4/PHHjyQT+/KXv8zm5ibXr1/HcZxv+tzv6Cu8Uj+Mzdww9iUeghKLATbw2K0B8FFCLtXLy7Op5FpYgdXDE8mtoGTFCM46IUaWCFHiWMstBpROlWjriQxhLZFwSGszawtoYXEK0E4le2pYj1FNV0SZYFL7IHS0T3cWRQfs1wm9xkQwqnW+KzpgXyZ0rMt66SGlxlJiKenW1EJk/Bkw+8YhFxorLI6V9fVUxQE+LlkNzo3FyFg3OajB9eFyCWyBbw0ODntyFyMMq3qZvVqpsaRb9NSUyghIRIYVFZi6ODM+Oc5Dxl6Cmwv8rkSoAjcUuNZjEtSft3VRiACswBUBWb3K6JgVurJOBppVJiIhNiGusRS2TyHGWAsBLZI6edq267No2CtjUreW+lmHtl1CWrBmgoc/S+h5xKQymRWJxCwzrrXHLbsBWKQtKfUAhUQJjyednzxU3DJNGL12OW2tJU1TRqPR7L8kSQ51/P1Wo+J/+7d/44knnrgvr7u/v88HP/hB/v7v//5Y8/8nDCGE+Cdr7dNCiP8D+GcqPG0/0JGuMYarV69y8+ZNNjc3Z5FtkiTHtmu8V5XZIjd85swZ4jhmc3PzSHMfVWI2Go3o9/vkec6TTz55x1ryS0ytFxXjWmGzgc+1evm/hMNuHa26C9Vk5cK7M3FAS8mOrKLVkdG4VDSNFi0eyl1yAeuiQQxkKsMho2m9mfohnkC/lky2CpeRV4Fu2wZMpjziIIc6Me2kplJZAF4xF6jG1mVfpHRFSVOGXKutJU+XLcbWYcU4tIxHZBNSkdIwAbedKlJd1k12am+HVdNkr45Ul3RET1XzuJnkwJsn8m6pwQykqyRdQMcGaHw6ZoWM5JCTWsPGM8BfNm32Z1FyxNirzqFdQbomqvbqQJQ6kLVwspKiBNGWWGWIiybD2q/Ct/6sXNpaSERGIhISlbAsVjmQhsB2WNItDDmusRjSubYYUCwm6pboylq2Jl2EgNCexLUSZQUTEgSHARckiRiT1cUtbbVOahNex9OHABeqpf6dCo2EEIRhSBiGhwyg7lXMcNSo+DgG5kd1GPsejH8WQvw/wPuA/5uKYpg80KA7bfr4Wkeu47Zhv1v3iMUIepEbvnbt2pGTY/cD3clkwoULF0jTlFarxaOPPnpHwN2xOYN6aX0CbxbFRouJs4WM+3ghebOvSkASWMGBV9EFa7js1hTBJv5MtxvgcsFOwMLriPm6KYCQNxChhEdbCMq0z4koYFhOSIqEaccf684fVq8VQv2SyJwF0JfVtQAMzJxCGC9QCBNRMpaasdRkWrKrCkBxynp4epkYibKSlokZiQnKzu9BxQVX5w0yh8yv5l3RTbZrkF4xTfZrkM4MXPSmRRoK12jadpXACgzMfC0W1QyRDRjX51g2bfbqqreGiRmEdblzLJFICuvTKDzSQuHkIcbLsZnAtqr5mmWbQZ1UdK1Lv7awTEXKRPoznfKq3sSIEs9YstGQUVz3TrOH3d8aLNMVu+QiJbQNEkY4xES2gbAenjVk9GmxRr82C3LwGNFlSWzQYoPXjuPyq3crZliMire3t+8ZFR/1nMfx0v0ejOeBnwL2gSeAtwKtBxp0n3zyyTsC2lHcvRbHazldYwzXr1/nxo0bhyLoxfmPy9O+dmRZxsWLFw8l4b7+9a/fFaAv2HkZrrcQieQLkq9eDaIOsGUzENDMLOOgOn5DBFypH9AO3gx0Q+78404X5u5TcpuS6xbC0CexEiFjmoEkyiUrQoI1nLQOpSjo15RDaBR9rzpPZBwmjeo+h6WiV+/3U9gPan/gQrLnJLPj92p1gG8VW2qCERbHClCCUoBjI5RQtPUKrrVoDK5VFEKTuwstiha46cVVwGKSbkU3ue1USboV3WBfjQDFql4hF5Jls0pJxlDMX9CLmmSfABbAeFd1QQiE63Hg1x03bEDke/hFhCw1aWGwCoQEZ+ySNKrPN3STQa32EFbQV31yUel8AzekdARN2yAyblURZyUODgMxj4ZdPBIxNQaSbKuamrBtUusQ25OUdkKAz4A9HuEH7/g70FofSR1wr3HcqHhqOnW/qPj7GXSttdeBPxBCfMZa+43p/gcadO82jkvkT0HXGMPNmze5du3aPT1tvx3QnfLCe3t735SEu1eftOuF5jHRRAtT/YBLS+YKdmpwayLZq0G0PTHsR9VDsiY9xrXBjL8ANmaBchgtRMXTORSwVdMWMZLtmraIU8M4qED6JAG3RcoIQ2BDXhU5WDhbNriiElql5KTx0bJACUNgJTdFj9y1rBJxvean153mbLuVO6Rufb39krSmKDqZx+2gAuMTOuamU9EGqyZmq3YqWytDdp0MrM9G7lOWOWs6xFrNRE4NdwR7M10w9BeSd4v630XLTNd63KxpjRNlmx1ZsmQ7dLQPoiAqQ1JSDpx5MiwVc8laYD2GtRJjxbTZdbqMHGiYiL5MUDaibSIIJF7uUMgxeZLP/CfCJGYcV58PTUgSVz3WurZHLmLGMkXZkFWzWsnTbIawhsGMwhBkC8nO2DbpyirK9W3ImIQz5k1E9s72iMaY75pk7G5R8csvv0yz2bxnVOz7/vc7vQDAIuDCAw663ykXeqUUw+GQL3zhC6yvr8/as99tTEF6sXfS/Y7VWnP16lW2trYOVcMtjrv1SQP4XFLwlVIgUIQIJrQ5KSUTZVhWgjUMw2yEkpaVsIlvdQWmC7dovJD536mB2ENwuwbURmro1a3cTxJwY1rZlglu1fmMTa/J+amUC4epM+wioMv67zIQhj5wpQaz09bjhogJM0FqA1aNgyss0gqaxmMocmTgQn1tQTOiX58r0wtGPJMJ1PggNDM/hmD6cxYChcvNVs42CQ+XLW6onNj4PFRGWFGC0CgL2zVP2zABB3XyzrWKPTlXMywCcyk0VkKXFN8G3K556Naghec4NI3CNYJRLU1zrcOBnINxsgB+ng2ABC0MCpftoIpSY9NCexCbDkIXWKfEWhACyqGemdBHWcw4qD2REeyqA8o68u6YDoJVQuPiWUG/1gMr6848KKBK9o1En4fs49xtHJde+HaHEAIpJWtra/eMin/nd36Hl19+mUajgTGGN73pTTz33HNHei4PDg54//vfz5UrVzh79ix/+Zd/+U1G6K+88gq//Mu/POvq/ZGPfIT3v//9APzCL/wCn//852cviz/7sz/jLW95y5G+3wMNuvcb9+Ndp562Fy9epCgK3vGOdxzJmew49IUQgt3dXa5cuXLfDhd3oyJKa/lGWQHRKelww9QGNkLyqtbsakuZZFyOqmzV6wqPb6QZ4HACQWkUm4GHduCM8PAlpKIkEIoWkou1sU2cWUY1uMZWzQBbLETfxSJvvLC0PphKyCwzBYW0ti6gqHp2bdWZ+xLL12VKKSyBFRSA1h5tG3IgBCu6gy8sCE3b+KSiZBDpeh7BqDm9LtiV49l5txeaUvbVPNKc1KA/lpq+MtxWFYg+VDYZiQYr2qVhfEKTkcuMyHhs1ZHtYpKuYYKacgBl5YwXBkh9Q7emRTbKNrcdQaAbdEwLKLAUKJgl4zzrsi8XI+PFSDRgR3UZyYRVscSeP8a1Mcu6iWxDOe5BWGAWKghFX1F26pdVEdB1KwAfCohkxERAbJdomiYlGbkdoZD0xT6P2jfU1Midx3826Bpj7vjcvjYqfuGFF/jEJz5BEAQ88cQT/Ou//is/8RM/caRzPP/88zz77LN8+MMf5vnnn+f555/n4x//+KFjoijiz//8z3n88ce5desWb3vb23jPe94zi6x/93d/l/e+973H/n7/ZUH3XhTAYtHB1NP2lVdeObIV5FGMzK213Lp1i8uXLxPH8X27Ei9e82vHRZ2T1XTAslQz0M3TFPz6YWjEYAoElpt1VNhBso0B6dDRiq/VwP2U8vmqMYDkKRnQNw4rjiBP+pyO2lhTMBgP6USK3JdMQgEYpIXbTA3RJben8ifrsl8vp9etx05dDbZpAm7VUrGTJuR6DXYnSo8bteJhwwZcqSPJZetxRVYSq0d0xGVVgHF5RLfIZUHHChpWUqicVBRE1uFWTTOs64idWkLVmEhGUc0jp4L9mpYIjcN2DdKOFWyrMYUwbKmMoTSVphhYQ+GYDg0r8ayio2EkJ4f43zXd5HZNJ7TykO6UkzYOO7XkLJWabTFhXCsg1nWLkhZt4xEbl0ROGDGmaWK69Wc867C/UMAx9bQoRIkRki3nANrQKZeZBJrYLKGsxrQKUpsjBMhCMhU3eEOPSatOaNqcLbU/q6pb1Us0aPNI8fpv+s0tjv9s0D1O14jhcMgb3/hGnnvuOZ577rkjn+Oll17ic5/7HAA///M/zzvf+c5vAt0nnnhitr25ucn6+jq7u7vfNp3xQIPu/UxviqI49Mez1rK/v8/FixcPFR1M/99Rx72KKay17OzscPHiRZaXl3n88cdJkuTI/O+dpGv/Xiy0K1+4zpFTLeldLDdMBRinpMPNuh/WSeXS1TV1IOS8sGJh7gGaEZZxaYj8kCTTeFpgvCZaw/rE4QYlazLiYaXQUjMZ9tloN+nJlBElq/h060i3ZZ0ZdbGYoHMXeI5DpMrCbV/kmfWhbbgtSm4LeESHXMWAVTyiQ4RRtIUkNIoNHDKR0/Q8RrV37pIImdTJLb+vSeoVZHvisB9X13zCxGxPy4+1z279chgYRSEMWlik9bFS0tIr+FSLgNB4JDLHWVBPLJsGt+ooed002amj4dh47MoBVsBIFgS2+qwwDrENWTIeqjb52Va79bU06dWfd6ziQC10ehCCoZwwlBPWy2V23CGejVnRLURoiI1PKoaoRc/isUverF4OXuKxF+7z2OCRyvTnHl5P38+gOxgMvqVE2vb2NidPngRgY2OD7e3tex7/8ssvk+f5oXbrH/nIR/jt3/5tnn32WZ5//vkj0RrwgIPuvcZrgbHb7XL+/HmCIPi2PW3vFpHu7+9z/vx5ms3mrCPE3t4eo9HoDrPced47JdK+Vs6B+GYyAc/BN5ZdpwKyh5XHFVMB3bJ0uFk3ZVz8404WoHarBuUIwfUarFcKy4FXPVhnXZ/ztjrnmnTYMSU3jGYZl38vM/BjTO7wqnEAB6U8HFo0BRgpOGMaGGkorSWwkhTDrpz7Pew4dbLOwlYdBToWtuoo0rOCW3fYdq3g1tS03cJNmZILw54FXyoSNMIomha8rEmQFogo4GTpkIoCpyWYqgtQc+hPh+NZZZ6fCai95ddMzPXa82FDN2ZRdUcHdJ0UcOjoiDGW5jAkCN3KVc0C4nBlUdtEjGubyBO6xe163gYh152qOaawlY9xLgLaJsQhYMn45CQ0bMBtp0qMeSNFt1F9XljBoE4M5qKkFIbdmsJY1SukMic2LRxryeMUa1OEgMDxsaUluOrzleFXZjmKRqNBs9k8pBg4auur79Q4DsjfK5H27ne/m9u3b3/T/o9+9KOH/i2EuGcAt7W1xQc+8AE++clPzu7Dxz72MTY2NsjznF/6pV/i4x//OL/5m795pGt+oEH3KJFuv9/n/PnzKKV48sknvyOetq8F9F6vx/nz5/E8j6eeeuoQoB+np9qdEmnWWv41rZbcsbF0vepPtqE1N5zqh9lekJAtRoh7tcmRMpZrNbhuCIedGnRPCZfztgKCVak4mDUsnEfFxcJ8vQWVw1Y9nwtcMRX90UTwDVvFq2s47FJCEfIIVeuWdSERozEqcsEVBFZwpS5kOGVDrtUKg5Mm4GodbW6acH6MCbg22464OtueUxebJuBmTWl0hJoB+YqpTIGWixYrVuEoy8nSJxcFo3YOaISFnjdfVezlg9kTUpj5d29Yl25NszStz/VgAAFsaJfbaoxnQzbKCLCslx1ykdGVc8nfot1lw/gM6x52J3R7RlkUGC65BzMwnlhNYFcIrCJN+wSRSypT1swSO2qagAtm/e2wlYJiJCcM5IR1vcy2ynFtzHrZwjqGHyge47HHz1aHW0uWZYxGI4bD4UwxMC022tramrXM+W56LsDxIt17dQK+W1dfgBMnTrC1tcXJkyfZ2tpifX39jscNBgN+7Md+jI9+9KOHrB2nUbLv+3zwgx/k937v9450vfCAg+69htaar3/963iexxNPPHGkbqHHKXgoioLhcMj58+cB7mpSfpyk253a+/zL+YuI1RM8Hge0XckEixEWtxyz6UoKJQ5VnN2uwaGJYKvePpGXbNc/4mnkCpANh9ColkTWc8FUUeeuncvGrtcRdAvJzXr/clJyUDvpnRUel2r1wyYu5+vt1SnoUtEMr/7/7L1ZrCTXda757SHGHM58ajg1TyJZHIqkaJn29bUt327DDeNCgtEGAQm23G54uG/Sg8yGDbdhoCEL8IuhfhAaEuAB8CDIt2UD/XIBy7ANyRZFcSqSNZ6qM58685BTTHvvfojIrCySRZ6iKelSuOulouJkZkRGRvyxYq1//b/LwVlO4TOHgBweJmCzsIwLBXjMGI0WjhDBtLDsi/weh+P7Hreh0oU/VLyIDAODnhHnsSUzNkVB0wRcq2q7p0yNNQfjzuOw9XGygMIinGMtagOOMJdsVM4ZwsBqXwLSOfaGLI36kQmHQzFbZbPHigYbssWYaTJhA5woGDeSVGRsDDfjhihrdRfSEm8H47oNaE8BwhHaGonwGLNTWFcQODkwIZ20o2xWGW/gvEGdOBcFPVnQEymn7N2xdyEEYRgShiGTk5OD9UVR8OKLLw6U7trtNtZaoigaZMR9+tYHxSb6oED33aIvbPP888/zZ3/2Z+/YgMuyjE9+8pP8yq/8ytsaZn3Ads7xjW98g0cfffTA2/6RA912u83NmzfZ39/nyJEjnD9/fyrMcDyIMI0xhuXlZdbX1zl//vy7/ujvx1Ntf3+f69evo7UmO/MQL6xl0IMfr2m+0yuB7LyMmG1rBI5RLehZxdlQ0paWCSU44gl6wqGFxfZ2+UgclVJ+aU7DGVItyRs1cAUaNwDXcaFYqzLhE8LndpUJH5MeV6vMuV7YwTBpOJQVD9PTuvcMbdz9/tte/6WOFTKsEOw4S4ecnrV4rjwpUyMJXEAXSUPUGRUCIeGEq5Fj2KuaXt5Q+UE7BsvKOXb7FnRDjAqA3SFwS4TFCsGmKIidx1JV7jhla+yYnAnnM2UDiiIHYfCdLMsBwGhPsxdX1Lse3KnoW8oK1tXdAYquyLECtlRG6AKWK5bD8WKEjuwxajxiq0hUTmgNYAbNOIDekExlw4a0dbmPozZmpdqXyPqkIid0DZo2AKdpmlG6ssOIbbBWZcOlFsU+H0sfuWfk+X6htUYpxbFjxwbr+lY5rVaLvb09lpeXSdMUrfU9QFyr1d5XWeJBQLfdblOv1x94G88//zy//Mu/zFe/+lVOnjzJ1772NQBefPFFvvzlL/OVr3yFr33ta/zzP/8zW1tb/Omf/ilwlxr2qU99io2NDZxzXLp0iS9/+csH3vaHGnSH76xv1bTt9XoHBju4q8H7bj92X8pxa2uLer3OpUuX3vPu/iCgm+c5m5ub9Ho9Lly4wMjICP/tzt2Ld9+W6KZwLFcXzElfsVgYQFAXipcSCzjCWPNiUppEHi8iljYlwgkaUtAWAeNScMc5xnXACV+SCkPebXF8pM4hZbHC0nSSnnC0nUEMeXol+u6FtDbIih1LVQMtRgyWJ1Csij73V7Na2f6cwGepYjycJOBWBYrlclK9JuCGSNkBQhvwevVIf85FzIqE0Gk+IkIyWRACAYK2zOmInKaRrFZSlcMsimkTsN439rTegNJWc4qVqgTgOcGq7GGFYIOcVMJ+BfKHXMieiZhwHg3tUSsK0iJBZZaNMMMBzbZkp1n+5s2uYjuuGB9Wc0fdHczYlQktmbMvc46YOqsqAQQni3GkMIROEFrYVx1wEDo9aMxBSfvrx6iNWdW7dEVGzYXc8qss1wZY6ajbKTwHvoOGNZwv7oLog0bfKieOYw4dumu/k2XZYMx3cXFxMFo/7OJbr9ffkyV00Jrug2jpvjUmJib4h3/4h7et/+hHP8pXvvIVAD796U/z6U9/+h3f/81vfvOBt9mPDzXoQgmEs7OztFotzp49O9C0vXPnzoGt0r+hbrF8IWdNL3NWTHDU1akPtXPzPB+A7ZkzZzhy5AgrKysfmKdafyR4d3eXMAx55plnBn/7Xrdqigm4nZWfcyZQzObl8rSWFehyT6a5UVTeaDhWdfldTmjJYgWcJzzNK2nOcu6YUZLvZQVQh57k9bykk53yFfOFh0SzpwRa1DikBWnS5oyOiZXESsOY0AROcEek5M4w4zxuyD6FTLNdgcMomtWq5FC7x+r9nZkNwy1FM8QP7pdTEgEtLLcr4D/jQm65Uhf2bOFB5pj0Q2IUJ5wmF6U1+IYrlcPGnD9gXRy2IbcrQJyxMXNVpnrMRixV9eJJG7BWgXQHyxXZLZkNWuBLTWEVE9YjDD2OFoaCAi0c+64Dos+eqBTWuj5btUooyN4VE1JOsC67lUYFTJsa68qhXcy0aZAJQ7e1z0S9zrruA6seiMXDvW4gExWbYpce46bGturwH5MLB8py4cFYPb7vMz4+zvhbbNX7Aw1bW1vMz8+TZdnbxG/iOB5cT0VR3OOU/V7xQZU1flDxoQfdmzdvMjU1xSOPPHLPwT+oIzDAOTvCv47fYYF1Zm2bZdlmykZM2ZBoJ0ctt3lk7Bg/fr6cImu32/8up4l+FEXB7du32djY4PTp05w9e5bLly/f/btzvNqtAMVX3KiAdkILZquvNvzJy9XfRyUsVEB8JM9YqDKLaV+zmJYX+vBpul0xJqRzzFXvG5eCheo7ntEetyvu72GluakibvYcT3mKV4oCEDyhPa5Uh2TS04RCU5fl/p2pBMABJg2kWrBeDS9IB8tVVuw5WKxqwqETzFfra06wUGXCNScHr6k7ec/6+QGHWLCocwqhaLkcQUFqHcpBgKUwERNC0UNy3DYRwuJw1K2mLQt6Q42uYWujhtNsVts+ZENuV2yGQ6nHatQ/1xRXqim1utV0fYO2MVPOI6grjuSGnBwxNNjA3l1FtokkYD2qJgFNOChTCByLul1qGo/J0rkZnxEbMGYiclFgRIbnYE33BXTUYLCj3DNJzQZczA+mkAf8u5kLUkoajcY9/Y7hpl273WZjY4NutzsY8+2P/L5XmeF+QxT/vceHHnQff/zxd6RZPYgw+cNujCgX9DyHqy6yDdkjb/XYnYJoUvM9lolZ52E7RhBLTDPlJAkjBPdcmG+NdzoprLUsLCwMnC36I8H9ceF+vNkr6FWJxpgum08A6VDysZCX3/GwFqyZ8jgctgX7svxppxs1FtLyjb2hrGWhAugRCfPVcTpqClYqb6+TWrNTDVOMKjlA9+Fvs+/u7uuKLZc94Lox9ICmEFzDYnPBYaHYEAaIOJ4JbgjLmBCclJJMWaYF1BAk2pBhaTjJjUr57BjB0LLPtar8MIPP9Wr9jAu4XtHJjhNws1+icCE3q+z0lAuZlXeHGK5UJYcZ47MsMzAeR/OYlrQcMg1CBE5Ypm1IQjGgqwnn2BoSX8/k3eM67EU35UJuyzYZDm08rlUaEdMmYCtIiEzMtPVRdclUakhdSjJ0GzXtdDDyO5VFrASV23Ib1ithnA4587oYCMxPmxrO1hlxPk3j0ZMpPdkjdIoN1aqy3IOD6PeDo3u/pp0xZtCT2dvbY2NjA2MMURTdkxWHYYgQglar9YGwkX7Q8aEH3fvFg8g7KiQP7cW8PNlhSbSJUkgDCOsx0KUnCk7YBguyxatyAxNA8RHLir3Ohuhx1NU4Y0eYcBEzrs4oPvIdTuz+lNrc3Nw7Cuq8NSt+sVPgCchd39OhzHjmqjLDEWFYN+V2ZjzJelqVFORdaNypbkiecNyqAPqEVoNM+LSnuVw9EdTdsCrX3f3ervZJ4pirMt6asdzGghAcE5KlajvntOZqxY44rTSXTZWtdrpsVEyJce2xaDK2HBx1kjeqG8BDQnItL7d0QWo2CBhBkijFEVEnlA6F4IyMSIXF4JCudNHoDGWnvXvcLobKEkPLauj7hUNA2RCaG9VY9AUbc110wcI522BLpIyjmHKKQhY0rY9wsFo5VtSsZnkgrAPrQ+4X3aHMtoZiq9pP6TS3dGl1NGNillWXehEwbQOIHBO9jESkA4oagMwrIjAwXcQsV84WkyYeZMaZK9gWiqQqUxwrYiaL2gNlufCDHYxQSjEyMjKwOa/VaoOmXZ/KtrKyQpqm/Ou//isvv/wyWZbx0ksvcfHixQMPJxxEd6G/P4899hgAJ06c4O///u8BuH37Ns899xxbW1s8/fTT/MVf/MWBp1nhRwB0380m56DlBeccJ+8IXp4EhOCwqjNPizuqO3BR6Bs7psJy0jaYFy2WRAuF5IbcJcWwUImknLYNJIIZV+eoq9MKLesb68zeLL3OnnnmmfuKQg/HP85LNu/ESGG5HENhNadqsGEcEYamdjg/RJqCvZ0Wx4KQWhTgS8HjwqGFw1o43e1yeLRBq/JlmJQSoyBxDm9omy1ZXlwKx+2iPHaTUjJfDVuc1R6zFT/3tKd5s8p0g24PovOTf84AACAASURBVPKEN2kGla5uz9y96RX1mH66vFxlxQrHfMWUCIHb1d8bCObIB08dr5oCC0wi2e5ndMJjkwJFyBl8etJyXPpEgFOWGVt6em1EfYF1xUJ162o4yUKVCYdODJa1g6U+BcwxUHADaInSEbmDRTrJAqUN0TkbsekKRixMiZhCGqRwBE6yrroIYNqGrPWdM4aAWTrYGALm/kReWxZM2pA53QFdirovqg7NwmOy0LRdi7GuRyIyNuTdwRuT5AOx+MOmzmJVZpgwEUu6xX9KTj9Qlgs/+Gm0/jb7ychw026YS3v27FlqtRp/8zd/w5e+9CXeeOMN/uRP/oRnn332PT//ILoLAFEU8corr7xt/e/8zu/w2c9+lueee47f+q3f4qtf/Sq//du/feDv96EH3fvFQcoL/bHgmzdvopXizFZEd1TRkWaQQfVBd032mHQhmyKhXT3nF8JxzNaYE/ssihY159ERORmWFdnmFnscySNWf9zxnewah6cbHJUeqd3jMDFTLr7Hj+yt8W/bJcCcjCU3qppCLAULLQtoYj/ncruc4TwajbG+D0cSWC8ABM80JS92DDDKfxCKb7fK43GpLrnclQgcG75gt5AcDwQrLqPpa06Eko5xHFEwgaArDAJHwwp8KchxRFIwZaHjLFmtBrZAAKsVsyEwhtsSkJJxY1mqHsFPSc1clQmfVz7XK6raWeXzZsUTPq083qgm4o5Ln8vV+iNCs02/QSfYFGAQ+AjesAYsPCp83jAFoDjdgxWhqCOYlB41aQgE1BF0VEHqDCNOca1qlJ0i5FZVrjjpQuZlXzciGEzOTTjNougbdUrmRQJC0JaOOZHSqm4Kh5zPmpV4LsCzIYetjw+ETrKrEloi47ANWejLUpqA1Wo/QidZrgY/cCUIOwF7ImdEajbGFGA5WYyyqDqMGp+xXJKLgpGOJJEZq7J19+rODLGveTyd5gEx9/sq63i/OAhlbGJiggsXLvDMM8/wpS996YE+/yC6C/cL5xzf/OY3B4aWv/qrv8of/MEf/A/QhbKA/26d1/4UWRAEPP7447TbbZb3d/irsLxgHxENeiJnR8BRNQ6yIHKKXZWxJRMabWjVYVskCFf6hU3biNsiZ1m2GTU+eyqjnSXgQeKDs4JvyxU8uYpCYnA8ZMep4XHU1Zmx9YFDwY22ZaNKtA6FYgC6d+u5jvmi/PlORYKlvPzDmUix3qoUuYYusPW8fOSOJFzvVaWAUDGblXSzQ77ixZ7HelIyIr5bsSaeiOD1BEAw4wtWCkUoHFJC4nyOasFla2hqzQVPsFVkTBQZRyMfG2iEswS2YD8tSJ1FZT1qcUBPCWyWDc7A4QGPzlD3fXuobrxRjdgKHGtVCUEAK9VTiMCVAxzVFNemXx6ALpbbrmDblDePQ0KzYUq7+SNI0jxgTEisVJwSdWQ1oHEIn31REA8h1YTz2K7oYzMu5EaVtc6kmuWoqo3bgJUKpGtorskeVpRUNF9CDwtOEzpNM28SIak7gXSarsiZdP6gSTdj4wEAN63HStWkEw52ZIoVjm2REusaS6rcr1PFOMuqy2jh0UgFmcs5Mw+vzr1c7lNF4epzat9NxvSDEDB/0DjoNt+vlu5BdReSJOGjH/0oWmuef/55PvGJT7C1tcXo6OjgpnDs2LGBh9xB40MPug/avbzfFFmSJJzbMoxOa3Yp6AILzjDv4IKNuI7Fw+GLJrEQeJ0O00EDTxjGidlQHe6IDsoJjADVzmEEWjVHoyNo1Rx7IkW4Uh5xxtaYk/u8Ljdp4PNvYpWjtsadn7K8ysv03AiPnFZs7MTkIqJyN+Raq7wpnPQNcxXonggFS1UlZbiluFDVeEfImU3K1z4cSV6tQHfaF8xWwD5sR7NU1Vhj4bheofwpXzJf0dAeCjSvZSXAHPcla4llu4CdXpvZIAahCdG83iqtec54IbcLg8QxoWtsdR0BjpvC4GFpFhnbquC4VsRSIEK4oEuT920MNSRTQrFQUcNOC5+5KuM9K3xuVgMc50TAzaqEcLiXsxqXYHIKj7nq6eQUXlkaAI7hsVQtjzrJK64UYZ9AsU2BM4IGATdxNGXEiJMYCaddjQJDKiyeE+TCkaq7x294Km7S+exWddWykVeC5nETstgfV7aaWVlgRal+1sES5XXqKHwnOeIUqSgYQQ5MQI+b2iBLHjM+y9WEnXKwKRNyYdlQKUEQsyck/9vUY3hT8h4K18bGBrdv36YoigGFqw/E/WbVD6O8AAe7rt9N7OaD0F2Yn59nZmaGW7du8fGPf5zHHnvsA3Gp+NCD7kGj2+1y48YNsizj/Pnzb7tDaq3BWD4uJ/ivdpM5l1R1w5x2VWvMgXPEXHUdNhshowXs4jhJyGLhCIzjWDuh1ggJYs1Rk9MVGdJmgGNXpByzDZZEizXRQTtJISxjNmRfZKzIDvUOLNfaFHHOzzxZAsidzTpnPENnL+DGboO4FXKMiLmKmplVWaIAblaAejIULGTl8jGRcaX6qaOhDtJWn8srHNeS8jvOSMtSXr7moVDzalKNEnt3QVcPdeu3quacdI7NqAbW0ZBwrQLlGSW5XTXtLnia61Wd9yHf4/UCQHGsFvNyXtZIL+aWN6rm4Lm0y2ylAjcmHEqFNKWgpiVnZTkyXBeSC0KQ4ggdeM6RS0EcRlBlwN6QNoU/VM6JnRjQMcaEpJ/vTOOxVf3mx/G4IhL2HdTxeKnydTtfDXEIpzmeQqJhRkRElE3PQy4idQWLVYlCOMf20CScG7rOx53PTh+YbcwtVfJ6PRtyu2qM1ZxilYIwjQnSAhv6HM1LW6Iakp0KjI+ZOvNVljxhApZUl/8lPT6wKBqmcPWzvWH/slarxerqKkmSoLVGSjkQ+X+/E2bfr9jd3b1H5Hw4Pgjdhb778ZkzZ/iZn/kZXn75ZX7pl36J3d3dQQlkaWnpbS7J7xUfetB9tzuilJJOp8Pc3BytVmvgRfZO0W+8/Zwc4/+1mzgEE5Sgu0LGDAHLpKxXmqVOCA45n11RME/CWM+wFyn2R5rMkoMxPGzrXKeD0Jqz3YDAK3mfR105d99wHnNqnyWxP6gHq+ppWkcpd7ZiDk90aTZ6eNoyNdJD1zJOTHSwDqY3GiS5Zq8dMaMiRosaV7vlRXEsECz0dcWHjtFclf1OaLiRlMsPx4rX04oDbDNWZdkUS3tdEGXDrz9s4QnH9Yo9MW4LbpsyC7oQKq5XGfJ5X/NKBbpHtGClyqZrSgyoZ8MmmntDrIltr7z5SRzbcQzO4TnHrHP0gP3MsKwgk4IGjkwYcqDhHD0JRoQcFZI1CYelx6iUCGl5SESAo5CWSTQGy+0KqELHYNlzlA03Ud5IVoeAcmdI8Kc/gOBEaU2/pGHJ5TzsQq6JHhh4yEXcMSljQjGDJhOWhgjQzrGjcpQVhEKwUFHRpHNsD438DmtKHLEhN1WHXBlqTnClAuMx63FbpARFyITzyJziaD6CEYYIQW4cH83fGZj6cT//sjzPmZubI0kSFhYW6HYr/vEQfavRaHygAjgH1T+BMtM9d+7cA2/jILoLOzs7xHFMEARsbm7yrW99i89//vMIIfjZn/1Zvv71r/Pcc8/d9/3vFh960L1fZFlGmqa88sornDt37m3DE2+NfuNtUvj8mGjygttn3iV4omwc9et6WxScJeIWPeZtFyUcRgomwzp79Ngg5xQhcyQsuhQtBIVU2ELxRtUQOm5DFoExFH4xRkNKJpCMypw9tcdIHrDnJTSr7CcODLt3GowebnF0tEva8wiinDFZMDbTAnbY3aoxMt7hY3sRrVaM6sU8m8ck7ZhOz+eRyGMyhL0EpgUcQrKFRQrHaA5PSokUEEuPp4UDHMLBI8ZAkZMWjpNAE8eOlkTAqUBzUwgS56gP0dTSoVr6asUd9nDcqLLiEQnX8ruZ8K0qEz6nFTer5Yc8zZUqK37E93i9YlM8HPm8Vi3P5IbrlRzlVC/hdr3MiieF5DVTgIEntebVrHz9k57PayYFFJdUxJZNGVWKE1KROIMWJQC3ZEGCpekENyowPmU95ga1XM1iBY7jTrEcVOUYJ5irqF2l4HtOJhxrFHgIVijLF2ddyLzJEc7jUSJaoiASkjqCrihQQpaDIpVGQ+Qki0Mc4UTfPdajzmNH5iRYQqu5XoHxtA24KVN+KTt6jxHng4TneYRhSK1W4+jRkmpmjBmUJ9bX17l169Y9XNp+eeL9CuA8SA35/YrdHER34cqVK/zmb/4mUpYlmeeff55HHnkEgC9+8Ys899xz/N7v/R5PPvkkv/7rv/5A2/+RA92iKJifn+fOnTv4vs+jjz56IAL1MNvhWTPJ3+5aJpXk4UDRE4ZUOc5JTSEMIssJpSHxFeeJuUGPW/RooGgNiSu2MTxExA26zKuUOoo2ZsBY2MFwgYjrrouPQBtJ12sQbkEn8rE9RdxqkMsCJQ1JxyOs5fRaYQm6kz3S/Yig2UN5lYj4aI9eqjl0fItJAzb3SArJ0lqDMRdyayViYzvGNXxe2iv3YzyG9Uww7TvuGHAInmoKvtcuT/7/OBbzwn4Jno+KNldEKTDSVQmL+CgciTIY6XHUlywnjmmpOeJDN7c8LGFUypKXKqEuHS0cRjjGhUAJQ+JcJVFZcYKHLtiU4ax4qLQh75ZV2vVSSlE4x3yWglblhF3WAyWROJYrupvEseoK2kDbGHILa65fXlGsuPJVZ5Sm5xyjQqLwOI6HFtAQ4ElFgmFSSLarx5NTBFyt2A9nCblRsRxOOp/FIfbDrQqYAwSzIil5xa4sa6z3qWguxOWSURTTTpNIi8Og8nygKTFmPeaHeMHDoj6hk4xaj2fN3ZHc9xPGmHvojUopms3mPap9w1zaYQEcz/PuAeI4jt8TUA8qOgXvv5F2EN2Fn/iJn7hnOnQ4zpw5wwsvvPDA2+3Hhx50+3dTYwyLi4ssLy9z7Ngxnn32Wa5cufJAWrZ9tsPH/JAjymPZFAQpLFXrH0XxOgJQTBmPXS2JlKLp+dQVjElIpaGQhpNE3BEpW640hzQCZgi5Rod5ehzCZ41s8Mia4Zhs5XQbkmTcke/6RJMZ7V2fcNRiEcytjtOwPTyl2JgfJ/AsgXAYXdBoZqyt1zk03WZyvEOaKoLA0GkFNEfbPFJPae1H/OdzPfY75UV0aC+m2G9wZTcg3os5G/us7vcHLO4emztJ2RDzcSyqOlg4HsBiUZYhHo3gcqrAwKlehzdkSRYN85RXbdnMeqomeKXydzwfSmYziwKmPMFGoYglLAvInMeMJ1jIHIdkwJQGkzsuSkUkBKk1nM3KG1/RiPCkYFJKrlSA+pD2uVKVBB5SmqsVD/hkWrAQVY3HzLBQ8egvSI/r1XvPSc1s1aw7JTXzrhQM8pzilYGAj2TfWYyFOpIVHCbzmESwIyXHRA2FQwnBjAzpiTKD7scEmq1Ki+IUIdeqQYyzhMz2pRyd5rZIcAIKZ9kSBT1KuclpKdnFp5ZLRl1IKCwepe76lswIrWMEzYLq8cvZDPp9Zrn9OAhl7H5c2r4ATqvVYmtri06ng5SSWq12jxrZMMj+IGQdf9jxoQdd5xxLS0vMz8+/bcrrQfQXhkMKwSejOv93e5dFU3BKSuaxzJsCqSQWwaiFLQTXjOUh6fHdLKMhBDmCDMVFFXDLSJpScCZXFD50fclZ3aComh8tYdgQOUe7cCeGrZrEM5ArQd5TRKMQjma01iIah3rUxhKQAtsoSLsRtakuBljaGqVJSsdJOitjjAeWna5keqJNPNJmZz9krJlQCItz0KxlLG/UOXt0FzO9x3GjiIOCze0Gk7lgcz9mZz+ikcXUMsetvATpJxqKlzolKJ8IJUvt8oYWaglVrTiN6pA6NI45V/4ODVdwueuq6bWC2ay8iB8N79aSL4aKF5OSvnbEU7yQFIBjNFa8WNHXHlcFrzsJRDwZNnitXa5/LFDsZtCUAhMojiKJJERC8KgoK6NxHBBg6TlDoAXKGowUtDodiMrvZ/J8cEXUxF3rhzGpWKm4xTPSY6cqEx3qFdyOFQjBuAh406Xg4Dwer5OBgWNoLlNQFyFHULSBU6JelqWEYxqfFsU9E3UNNBsVMJ90Ideq0sIZFzJX6eWGKN4U3YqKVmoW77vSxmjMBZwxIR/7d2a58O8bjngnAZx+eaIvlD47O4sxhjiOqdfrSCkRQhyotvt+rXp+2PGhB10o76jvZJv+IPoLb41fjGr8P+3dMr9JEgh9WkpyUfu8UWTMaUXNQUdA/4m35RyPa5/XTcoVkzImNDvWsIFixQKJ4wkd8LpNAMe4CehgqUnBRKqJJXR2e9wuPLygwLZ8ZCNDB1UXPrR01mJqh7o0p7rkbYVXNyhlEZ6jPm7YWo9Jm13CmmE3r7GfGFodjyz1SRzstkNmxrtMjHRJMkXoG3b2AuKgYHK8hd2POHvoDjsdn1+IU4xRvHlnlCTXNIsajSKklfosVsyIunQloAJnA8HNimL2RF3xSlI9ITQCvtOthgY8wUr1k/Q6bdBlHXYry4GyDNBXTfOF40bVtIus4YYo2QYTUvBG1ag7rARvZgUWQUNKXkyrLFIrXhtaXqieeE5pnyu2ADQXtGZPhkxnglFXkFrD8Z5BFDk7Xs6kp1BScMtLQZaTcjerYQ5tLOthCUYC2HB3z7NUugFg14TEUaqhHXOaK6Ks6z5ifa7JrBwxJmaJnDFipoXECDhja1gMHeGIrCQR5p5R4lGn2apqzKdddFd3wvrcUj1+rTh6TyPu/cYHTRm7X3mi2+0OaGz7+/u88MILA/ugfoliWIkMSvrn/wDdH0JIKTl79uw7DkK8H9B1zpFlGcuzszzpC77TqLHg+4wLybazdKtOey4EFxxcEY5rRcYJrVm2BevGICj5sselZscYlpXguHEsKVgwORooBIxbwbanuAF8pPC4bFOU8rFaIDyP3q5PYTL8XJAv1NC+IRRQbEfIoIAOUDfURzPMdoQa7zE+1sPlEulZ5L6HHC8Ym8oodkLi8YSiJ9lxIViH3dEo7YiEpbPdwKsl1GWBszBWy2jtNBgZb/HokW2M0fjBGscP14jihE4nZn+3gcoDNjsxaeozoiTTuvR6GBFwKVRYVzaVPuJLCufoSM0h7QiBNRUhLJxQjtu2fAw+ZRLmitIO/CPC8KYtL/hHQs3LFYPibKAG4HrMU6xVWfa0liz3mRVKsFiRIkalHIBuU4oBmTkUguvVZz7pebxhAaV4MqpxpSjB8WLh2LAQWEuz12NfKyaFYDrwyb1SlLIuygGNCMeM1MxW03QzQnOzKkuMILlZlT18YFXetazvYEmEY5WCuvOYrYD5YRdwTZSNv4eJ2RMF45mgZiwulpyoaGnr8l4q2owN+DH73k4pB4kfBE9XCEGtVqNWqyGEoF6vc+rUqXvsgzY3NwdKZEmS8MILLyCEGIinHzQOorvwj//4j3z2s58d/P/q1av89V//NZ/4xCf4zGc+wz/90z8NwL4vav5A3/c99DIPLqb5Q4wsy94RdFdXV+n1epw5c+ZAn/Od73yH0dHRgW7uZmOc/zzbYsyDx2LJlrNECiY82E97aOEIYp9COEalYIWcDpZjSnPVpASUWrEdHCcLx0KViF/ILbOBQFL6eG05wwlxl6jv5kLU6TJzsdsaOV5gdjVqJEdIyJcCguMJzlnMnZB6zZB0wZOOkZplvy1pHuniRQW97YDaREpv3yOo5UgF2ysx40e7ZQNk36c+ktHb04TNApML9jcDfN8QSwcqZ6SeYhOf2mhZf2zv1aiPdGh1fOIwRynH/FqDwHMs78R09mvc2o/YaIdcrEveqLjDz44IvtMql39qRPLtavknR+FqzxJrwflIsFkUuDwjKhKcVzbEAmkRvoenFJ7SZFJihEMI2HclxawjLC0cE7IcMMiBKSnYdQ4DTEvBNrZalmzZcnlKCPaxFJSSlv33NkVphZTgCKxDCUdPSbSD2Dn2pUA6x7gxbHsVdU5JWkBdCg5LSYJDCEdDCNYp6GKYEZI3qqbXeYKBxdFRNGsixwmoO0FOKdgjnWNCKDarEsTJDJaC8nx/2IVcEQk1JzmLT084/lfGuejev/HqcFy+fJlz584NXLO/37GysoK19h6niuEoioLFxUX+9m//lj//8z/nyJEjJEnC5z73ufsKjg/H5z//ecbHxwe6Czs7O+86Ary9vc25c+dYWloijmM+85nP8Iu/+Itvs+95h7jvY8aHPtMFBjWgt8ZBM92+1GKr1WJqamogtXgYeDr2+Fa7oJs7MlGO4T4VK17tldnYRwvN93qlWPW4Dtk0jsSHttN4Xln73Ex7dLIeZwKFV4sIfMFpYehhOCQ0W86w4HLOi4BZUjiUInKB8xyuq2C8QI0W2JUQNZOgD6WIREEIVkHSNNCEzkqArSe4yLDViRGpIW9pTOHTy8BtRoyP5YT1nKStCesFpigzzGikYGstZuJQl+ZUSlEoZFSwvR2iNBgf5hcniH0DztG1EWP1jNWdGscm2xyfarHXDXj67DrtdsR/rPfIjWBrc4wjieTOfozJYqQIkYgBR3hEOV7qQGIFdQXfahkcknNK8ZocAQNPxZLvJgYSeELnXK6y4ou2yxUdA5JnAseNTOIJOBYr5gvLmBSc9AV71qEljOI4xN1MvC4MCXBMC17LMxBwSmteqSQtzw0vS8mbFVvioufzarX+oufzRkUfO1VYZqvXuG7OfKBwQjCGoI0jByIEewIcAWNS4KTkrIhRQCwEPoqeM0wLxRtVY+0C/YwXpnuGpbj8/g0nBv50XSx3KJhwmot8MIALPxz79XdT7NJac/r0aT73uc/xd3/3d3z729+mKAp6vd6BPv9BdRe+/vWv8wu/8AsPJKr+XvEjAbr3i/eSd3yr1OLk5CRTU1P30Fr+96mQb7Xb7Fn4WF3z3W7BK92CQ8qxbsVA06BwgtO+YrNXMJvBxUhzNSlY7+UYqcnECE+gubxT7s9Toc/LaY7CccirUQjHSibZ29coC6NS0JMG5VncYohoFHh1gzUgPFCbHkVo8KczzGaAmkzxJzJsJpC+Q6caExv8qYLuro+cTHGZYNMptCewOx4uK3CZQCyXKl1SWNK2jxfl9DoeYVQwPp7S3gmpjyXUR3N8bVGeY32zhmgIXARXVscYCyytFIwVjNZSFrfqHJ9oMzK2S9NJnjy5ydJ2jZ98skuvG3Flo87hJOCIq/HNdQ9QjOUdVmV5co9EPnTLY9utHrgksKt8sA5PODaDGhhHiON6akFIPGt4qWvpCcmotCwXkDiYkNATjrRa7ghH5sr68JJwpM7jsCrF4adkQM0a7ux3OeVr6mGAUoKPCEdmDV3jaCLpOsPWkDaEDD2oGm7jUVgyV4DRJGcnrGb104KbVS34lPB4raoRnxFeOYYMTArFMgYfn0mhSIXgeOrIkh6jgU9kNB1RMO0k1yox+POutDb6L2YKg0EI8YFMj/0wQPcgWXW73R5QQfvebAeJg+ou9OOv//qv+dznPnfPut/93d/lD//wD/m5n/s5/uiP/ujAkpL9+JEG3fvJOzrn2NjYYHb2XqnFN998820g/T81Pc4EklupZTm1Vb1WcETBuoWFzPJErHgtMbzWK2hIQcs6et0eKI+OUDzlwSuF49Wk4JRfatmu5CVlyiA4ojQvZzmb0uJnGnM4p5OBcAJCidjU0Cy76eJahBw1aAPqep1a7Oim4KWCes3SbilqR3owlpJu+wTjGcYvEKYEY7PpQ5AixzLsno8ey+ilEqktQjv2dmsI3UP7gp07TbS2eAiSXYH2C2w7QI11mZ7ske4HhM0MGRtUWDDehN5OxF4s8ALH5tYYTlqsAWUTjo52aLVjRppdHlU5vm/QyjJxOCbwDLvdmGCvBnnEG3sBIHkklFypRpQvxZJXqgz5qVjx3V65/slY80Jl2PlYzeeF6vXHbcYbssyajpiEK6q8OE77kpeGrI++N1Qf/l6ag4GHi5QbfnnxP+MkL/TK8+jpwOPlXtn0e9L3uJ0YxqXmtJK0csdDwiOWkFjHORRCOHYDje/KevxSUAKYto4l04OqLJEMMScOSc22NRQ4Gk5whQwUXKg1eIUcCssR4fMqOXUTMEkJzD8vIs4QDkT9h+mSfVbAgwLxv9c54kHjoDzdvb29+zp8fxC6C1CWJy9fvszP//zPD9Z94Qtf4PDhw2RZxm/8xm/wxS9+kd///d9/z/0djh8J0H03Td23gujOzg43btwgiiIuXbp0z131nV4vheC/TEV8dT2hAH48lCway1phmHaGjtJUjXx6VnCBnMtobgmPh3zFjcxwq3D4zpEJwagULAB3jOWp0OPlNOeVJOeQJ1kzFuOXnW/nQ23DoxtmuMmc+q5HZzRHThYgBal2RJliu15AHVj3WWvkUHfkmzHGt4hdBalHmoBIBbWRggKHWw1RoxlWuHLsOLB0V0JqMz3kaEJvMySaTMkLixcYcu1orYU0DiW4oKC7MMJobGj1BLrtMxob1nZDDh9pE46k7O8FNEcyWqmjVsvREm5tNpgclxinWL8zhicNMRDWEyZHu6S9kFOHdojDhKlmj4/hmL0zyoiShLsR++0aeRYzU3iE0tFLBA8LiS8gy+AJ7aOFwxl4UkvAgqrxEVcOTHQIGbUW3xpeSwRIyZgteC0pqWyTAl5Lsor+5ZgLAnDl9NzV6pyoC7hZTdL5wrFoLXvO0TYFAjVwzzijNLeqabqLvq40KxRPex6r1jAhBEe0pIPjqHUEtmDbFkxkFq8ouBI5kIJabrmpElASDewMyRnVhOCOgz0sx4XPTZfyef8wvigvaWstzrnBv/3lPhA751BKDa6ddwPWH6QlzkF5unt7e/dlLnwQugsAX/va1/jkJz95DyuqnyUHQcCv/dqv8cd//Mfvua9vjR8J0L1fDPN02+02169fB+Dhhx9+x8eRvg37W+OTYz7/53cNmxl8pCG4WlGkHg+6e81z0gAAIABJREFUXMtDloDz9YzbmeCyVjSikrspcphxpQ36kbSFHGlSpI5ntCIDVOF4TPsUOLyuYKdlMJ5lZEWzd6SgM5bh7UuKpsW4EoyNDyNrHnuHMnoTBcGGRzGVkzULSAUEILuCogZuytDZ8DCHciigl2hE3eB3FHkuwDrqCzGpXyANmPk6TltCAb1dDy8yiL0QJnol4O77iGaGjg15ZIgbjs5GSDcq8ELD2lYTpw15T0Ie0LWWvY7P4Yke42NdOl2fRj1HFJqRkRwhYHW7zoTq0ckUWWeEmrbMro9wdLTD6al9upnmx6e32d2vMdLosNP16bVGmW1r1tsRp12df9kvQeE/NCX/Ug13/ERD8W+VxOWzTcUrXQDFj9UCFnuGmoTjvmIltWhT0My7hErja8WYJ0i1RmrFuJKsO0sqHDNacLkC3cd8n5fy8tH+Cd/n1Wr5UX13ZPmC1lzpjyxLxWtFhgHGhGA1N3Rx+JSlpE0UoDjtRyRZQa0omLKOVCukKYiKgtTXHNWKupYs6VLCcgrFVZfwnB5jQty9nPsgOlwa6GfA1tp7QBnuZsXD2fAPQ9zmoKC7u7v7vqbRDqK70I+/+qu/4gtf+MI96/qA7ZzjG9/4Bo8++ugD78OPBOje707c9x27fPkyvV6P8+fPv+sEy/0ab5ES/OYZj//ras61luOxMcHlfcfNLKCmHB1b+pf1nKaXw9m65F/2DNdacLGuuNIVNKjjEkHXCp5uSl7tlYMAPzki+dcKHOq7mt64ZSuB4o7GQxBtSEzTUHgCMR9AzbIjHHIvJG44uh2BygVezZLvKDiakkwY5JoHh3LyRoFIJCK0uJ5E1A1ZzWDXfPThjPZohkgUasSQ7St0w5FLSNdjgukMpyzFXJMoNJgCZFvTDB1bu4LGeEo8kdDaCWiMpUjf4rSjFhfs7gTUx3M8ByutGlGcYTLFznqIxCHWFSIuaMQZRaYYaRrW9zTxSEEMLO42mKil7CeKzW5E07Pc3mpwfKxD7G0xMiaoBwWrezU+4+fsdiJW9uqc0AEyjXmpW4LNCV/wUsURPu0LXuoZLDClJS+mBovkKII3wlEscELDdWsxmWA6yXhVaYwQTGGYk4IcySEpuGkcE8JnXAq6meMhEeLh8BxcVD7GWWqi9IbrOEdDwGrV6z2uNZcr26OL2uPVytLoovR4w5ZgOuH7XBPlSPm477GKJcGhnWPEOHaQeNaik4xTSvETRUK32SWKone9Hob/7ccwCDvnBgCcpinWWoqiGDyKf7+BuCiKA9WQ3+8I8EF0FwDm5uZYXFzkp3/6p+95/6c+9Sk2NjZwznHp0iW+/OUvP/A+/EhQxowxbwPLLMu4desWCwsLXLp0iampqfd8TOr7L50+ffptf9vLHY/9tx6tAh4dEVxuV0MAYY+XsxCH4+ExyeW2pakcVkLLwOMNyevVFNdPjUq+tW8Ax+NNyZs9y4gqFbfaFhpriu6RyjByWdE6Xk5l1XYV3XGD6oEKoNAQb0ryQ5Wd+Yame6goM9dM0o0Mqi2IfIszkiAV6Fr5mB06R+FbnLB42mAC0KnETJTjyvG2TzJRTlb5XU1WK5BdBaHBKYe37WMny4653POxzRTZVYROltl4BrWaJRMGYSEcTykyiZAO5VuS7ZB4IsE5yFo+QTMlb3to59CUpYIwzPF1AUoQxgXpfkDULN+Td0KUl1OkmkA6hCywRjI60iLNPJQqv9fGzggOcGnErf2IzW7EYenzWmKwAi7IgllXXtwPR5KrFdf3Yii5UtV7Hwslb1bLj2jLVVueP+fzHrNBWZZ6XFouVzqNz4Sa71XiOh8NdClXCTzua67kZb3/rNa0rCWUonRLFqVNTy9LyLOUJA7oSpjSiqWqKXdReVypGm5PKJ/Xqom4h6XPFZvxf2QBp/a6tFotut0uWmuazeZAwvFBJRmdc6ytrXH79m1OnDjB1NTUPeavzrlBjfiDBuIXX3yRp5566j0/8y//8i/Z29vj85///Ae27Q84frQpY8NhjGFubo47d+5w6tQparXau9ZthkNrTafTece/jXiC3zyj+ePrBZf3HGeChFtFyGwe0tSwXwj6A0P7RpSPunuG11qWJ5uSV9uWl/cN4xq2C0GlgsiegUta8xoFrUOG6R3J1pilNV3g9QR5BNqjLC1EMLWnWB8zdCcN03uanZGCdKzATwVZAGRAJDANcKs+yUxOUrf4W5piqkCn4FC4QOJvheSTZQNHXwsQYwVda7A36kjfEkiL2dZ4vsNseajRHFHPyTd9gskMF+aYVEHNku5p3GipG7y14+ONW2wmaO2W9uuqJ8llqZIlN2qkqkAIh5dpvHrB7nbAxESCD2zvhIzWUzodiUwDhIOVO03qXoGUBk8oRpsp67shUyMWh+XG9hihn6NzTYolVBmRkIwevoNuBPxYmJMUEn9zhGZumes2OZzUOaV87iRwXiqO+LBvHZe0ZERBxzkueZKadOw5xznpaEpYVjViZ5kWrhyoEDBVZLyalkadYziuVoBbE7BiSj5w2zrWjGWpyiQf8hXXqmThYeOY9WMo4Cnf480kY0R6nFWKdlFm0pGA3MIFEZLZgp5z/M865uONKZi4e67meU6r1WJ/f5+5ubmB5kG9Xh+Acb1ef8eMMkkSrl69itaap59++h761lvrxB9kw254G99P14j/HuJHAnSFEFhrWVpaYnFxkZmZGZ599lmklCwsLBz4h3w3Xm+SJHw8ucX/t3qK1HqcHNOkOw6J5IljjpfWYH8Zfn7KcXVHsL5iuRQr9jKIO47jbYfn+Xxk0nGjBXkL/tOIY74H6/uWo1lA5jmEcYxtSzxPIDqC1HOoAEZveYimpVU46muKcNTRaUO4K9Ah2JYgmihIhSCc07ijOb2xAm9HUYwZisAic0EROPw1RXGkIJso8O54FIdziqkCL1H0GoBxiJqlp0BuaMTo/9/em4fHVZf9/6/PWWbP1jRL071Jk250Lwp+VUCWB1Aef4hQVEBBUB7ZpQqUB3GBFhD0QRBQWV0oCghcivVRocgl0IYUpKVpkibdkzbNNpOZzHbO+fz+mJ7zTNIsk2ZpafO+rlxXk5yZ+WQ65/25P/f9vt93EnwS0eZB5BtIy0Jr8iEUiRUVZHktOi2g00NutkVCSsyghjvLwIhpuAMGuC3irS6yxscJm2DEUjrh/UE3qm7hEYKdewO4dYscXdLW7sbnNVANFVdWHJ+AWKcHPStGJKaS6NSIo7CtOYtc3cAAkqZGVnacSMiNJyCR0qSuPRevahIOuhGKxaScMFKqnDptJ21hD27dJNDlpiWURbPhYnunB5F04VYFraYkICRZmqDZkHgE5B9sY9aFQq5LQTMlAQHFbhc5loVqmgRkkohpYlkmfmnR5XYRUFUKNYUGS+KSMNul8sHBz1qZENQdzGNOUBSqjQQJICot6k1Jq0ypZqZrGtsPRr/zNRe7kwY/9h3qr6Dreq+eB52dnXR2drJnzx7C4TBSSqfFNisri2AwyP79+5k5cyb5+fmHPG9feeLhKtgNBqFQiGnTpg3Lc402jgnS7erqorKykoKCgkM8GGwizWREcm+FNMMw2L59OwcOHKC0tJQvLXDz6AaobYbJgTA7o34+bIQsL7THIBIVmAZEUKnIhw0RSX2bYKYvTk3MRdVemJALO8IgDQiZELVUctoU2iaaoAny9io0TjaRuZLcTsF+r0RVJJoqiPoF/g7BHsVC5kBxh8ZOrwXZMCHo4kC2heIGz343cZ8kEIdYXEORML4NImrK79ZXr2K6QNEl+h4Xig5eRZJMKKCCp12ly2di5hj4ghqRHAORZaDFBIZHQeuUJHwSfBKzQ8XMS6U3QjEVM2CidqnEpIIiBVqzm7hioUgJzV6SigQpkULgdptYER0rL4HfYyLCLuLeBFZMJZpUQDUxmgL4vRZJUxCP+/C5LRKGwJ8VJytgEg168edEMROClrAXRUhaD3hRNXAJUIXAn5Uk2uVC9RpIadDYkYdXMwl2gV8zKSxqpctUOKk0Rjjsp8OEtqiXrISfqqALDBfzfZojU1uSJlOb7VN59+CEjSUejQ0JQNGZ51HZeNBHYrJp8o6ZSifkGiY1CQO/ojBeU3DrGrNE6mb0KYICNAwkeQrsskyygVJd5f2DeeAKVeMDI8HdgXHkKJlpaFVVJTc3t1t0aI/uaW5uZtOmTQgh0HWdvXv3EgqFyMrKIjs7u997ZygFu6GkJ8Yi3SMMr9fLkiVLehUpD5Z07UjXsix2797Nnj17mDx5stOldlmuZM0HFh0xSBzs5ooZgjnZUBmT7AzB4gmCqv2SjU2S6fmwPQRNcQ9+DSKGIEsASJpjgtmqYAsWwUKLolaF/fkWwWITb0gQzQZDB8UA0w2BFoVooUUkV5K3T6VtgklTrkVuh0JHrkWrbuFNCKIuiTuZOoqG3VAU1GgeZ9DkkoxrV+nINwknJR5DocMt0TtVLK+JpQq8B3TiRQZoEk+Tm0SBgUhK3HvcKYfvqILXJYlZIFohkGXRkQQlouL1JekyVTQD8FqYIQ19XJKwK0mixYVrfIKYATKhogVMQp0udL+Boktie/24PBY+JF1NXnQ9VdmXbgO33yIY1fDnxTGS0GaoePwGB4IeVJdF0oLogQAJxcS0BPk+AyVg0BZ2UZQXozOp0hbW8Wsmza1ZqEKSo1o0J1Ty/HGSCRddmoWpWOzvyCN+cD5aWXYE1A7OGq/hcydoD2VztqEj4l6CMS9LXB5cApImzNM1FGERsSTFSmrS8v6DROMREqlpmEZq48lVJbvUVGBQZCT44ODnb1YyQZWe+pyeoKm84Zj06LwXNfApGkVKys/iEreXT7qG1ppr527b29tZvHgxWVlZjvlMKBSira2NnTt3kkgk8Hg83fLE9gy13tBfwW6g9IR9ah2IiEOh0EeWdI+JQpptUtMbNm/ezOTJkzNyI0okErz//vtMmTKFhoYGCgsLmTZt2iESlt++b/FUlcRKRJlR6KEtLlI+DG4wLPAoqelcUgp8qiQChIIhSvKzOVhHw+eRhBKwpxYSYYGaBYmoxNIEepbE6gLplQgV3CbEfRLLFOiGJKJbWEnQVYsuSwNL4vJbRJMKupSYHrAsyPFAh5Fqe83ySDotUBWJVMBUIFuDsLCQKuQIQYduggaemCCaY6VysTGBkZ0i86SQSJfEH1bpyjJBSPwhjWiugWLKlDGPT+KJgeGSWJrE3ykxvALNknhNBUtPjaFRVAsU0KTEdFtIzcSd1EhkJSAp0CwFw22iRlSkzwBM9C43qssCy0IRAk2TmAaoXgNFN5FxDT2QwIipCNVCCEmyS0dRLVRJ6u/RTGRSkJ0bx7QgFtVwuU3C0ZSnr4lEIMn3JehKqmR54pimINTlQVVNVAuyvfGUqXxSR0GwK+QnEneRDI+jPpEySZ/tUalOmPhFqiC3N55AMwym+FzENA1VQJYCESTmQelYi2EQlha6adKpKsQUBY9lkaVIWpSUA9ssXcMAHh83Hs8Q9LNtbW3U1tZSUlLC5MmT+y0y2zPU7DxxZ2cnsVgMl8vlRMO9uYBlApuAY7GYM507vZDdV0R8ySWXcN999zFz5szB//Gjgz7fiGOCdCElb+kNW7dupaCgoNccVU+0trayceNGSkpKKCsr67O9L2nAVffC7mZBTkASkRBLCKaXSOpaUtecMB3e35X697zpkn/vAZBMngANrRBwS6QqCSUF2XEIecESMK4Tmsel3vaiLmjKSpFmICzoyJOopkRJCmJZEm8cYprE1MEXFHTmSRAQaBMEi1Jyo0CHQuc4C2FIdEvQ5Zd4E5DUJAkN8mMKLV4rNUI+JmjMMhESCmIKLX4LPWmRJRQiSopMPV6IGaAnwRWwSCTBg0TqAtNKkXuXJcEU+LNNuiSImEDLMzAViRJRIcdExgSaKpFuiRVU0XMNJBZW0IUvYBBPAKZCjlcSiks0XZLltuhMCLwBA43UjAm318QM6whfEmlZyC4NSwNhgUuTGEIiTMjOSiCRmIaKz2fQHtLxu1J/a8IQ+DQLaYHfn0DXLWIRF25fAiumoSFQRCqv6nEnMQwFzZVEmIJ4QkdTTDQUYtLk7Z2TmKm5qTzoE7xEl7x/MJBb6Fb4wJ4jp6vsNk0SQJGaGqwZtCQ+kZKz7TNNchTBVBVCpolqmniTCUwkX+mKMPOgEXh2dvag2lCTySS1tbUkEglmzZo1JCObRCLhkLCtnFBV1YmGs7OzB1ROpCslSktLKSws7DMiTse5557LK6+80udgyqMAxy/p1tfXEwgEKCoq6vOxduOEEIJwOMwnP/nJAV+vshpufSz1vs4tk/x7Z+rfc0olH+wGBEwtgoYD4HdLpJakM6FTnCvZH5ckTEFBEvb5Um9x7n5BW0nq3/5W6CxIFdU8YYGRI6ELLDXV/KCGgTxJMgn+JBjZqU4snwkRV8r8x6NIwgBmaupEAoFbMYkIFRQIaKmKvKKBnhREdInLIzG6UlG1W5eYMQXTlyJ6U4DwSkSXwPBJ0CWeCMTyDhrXdKmEs1LtyW5TEPVY+BKCpG5hqJAbVQj5TBRpkZvUSbgMNFOiWyBVibAsFB1UFRSpgEuiCrBUiemy0JOChC6RqoU/phHzJlGS4JUqlmqBIVEwEZpAFQqq28KyQNFNFJdFMqKjeRMIU2AkVFRVoh8cGaSqJioKHn+caFzFpVoYliQe1wjoFlFL4NMNstxJOqJuxgViWHGVzqSKqphkKwrocQxLwa/AG9uLSMQ8lFoxDgiVLLeLEpdCl0z9TR4l9flISImFxKsI9lsWEdNikkvh3wcbMJa5NTYeVEEs0HU+TCb5n3G5LJBmt6gzHo/j8Xi6RZ09j//p5DZ9+nSKiopGpNPMVk7YX+FwGCGEQ8T2l6qqxONxqqur0XWd8vLyQ/yw02ETbywW44EHHuCZZ55hy5YtfbYCHwU49km3L3vHnTt3oqpqr1ZxsViMbdu2EYlEKC8vJy8vj7feeouTTz45o9e8+aftvL9jHEJIJk+Ejgjk+UG4U+94tis1jltYEO/qQGoeVEXH7xUcaBfsr1fQYhIzH+JJC7+pEPJLpASfLghpoBspgotpAr8lCetgqBDogrAfpALeIHSOl0gkvqBC5/hUhODrVIjkWQgDdCmI+CT6waixSxN445KYV5JUBXkJSZtHYApJkSVoclsICblJQatHolsSxRJEvBJvwiIhFJJuSXYCOhWJ0CSehKDLLXGrFkpcxXBJApokHhcIXeLTJFFT4NIlioSEkHg1SEqwVIuAAl0KoEl8hkXUSyqFkRDEvFZKA6wIooBqgU+HiJkyv3G5TKKmgs9toekWkZhKIMsAKYl2aXg9FtJMvZZbsdAVgaGaaBLcLonmNoh06gS8BgkDNEvBo6fyxR6XiapILAtUlwFdKd2xkBKXAqrLwjRUPP44RlIhmVAJNbvZHR1HWAqmuBT2WRZhS1KsChRFst9MRbWTXArbkiYKsNCTmqKskdL87jZNfEJQrKYI++IsD2f5D41MpZTE43GHhEOhkHP8tyPh5uZmvF7vgOQ2EjBN0/HFDYVChMNh4vE4hmFQVFREcXExWVlZA67r/fff5/rrr+e8887jlltuGfW/Y5A4fkm3sbGRRCLRTV7SU5FQWFjo7PqDId2339nCmmfn0LpPIS9f0NIJyaRg6nSL+r2p5yuvsNiy/aBB99Qw25r8SCR5SpIWTUdKSY4laHeBKiWaAV0+UOMp28aED/QuifSmjM/dnQJrnEUyLvCbKTJWSKUrogKESNkYJgUoisQ6OP5HSkkyKdB8EI1JFED1p/7t8UAUsEyJx20QI1UUUl0p2a9HSeVzk9LCpUFSS43W1IQkJlIkIhAkFImqSgwJliJRgQQCTbcwrFSe26dDl5VSLgQ0CFoSoVpkqwohYaErEi+CsGbhRqJIQUyz8B58jCHAj5UaaSQFWYpBUlWwLEHAk5KrSSlweU1MQ6IKBY9mYRgCRRV4lFQOVagSNwLLZYCQ6KaC1FLyAl2k0gkIDuaDBZZmIrQEWsJNUjGxrNRI+QgmliXI88fpSqggBX5pEBUqLWEPgVAuu5ISBcF0t0Kc1L+zVNAUiUVKu+xXBZ1SYpDyZt5lmoQtSYki2GFJvpvn5/yswaUCotGo8zn3+XxOi60dDWdnZ2c0LHI4EY1Gqa6uxuPxUFJSQldXl0PGhmHg8/m6RcQej4d4PM69997LunXreOyxx5g/f/6orXcIOPZJN5lM9pr7aW5uJhgMMnPmzEMUCZMmTTrkA/fWW29x0kknZXT0qq6upnnfZB75WaqKOnOuRXVd6vkq5lp8WCeQQMUsk+rtCn4vTJ5i0dYiCG1LzflR/RIzrKD6DRJJDaREcVskUNFcFiaCuE5qYoQGMQU8FiQ1iKvgikqkD+IKuBKQ8KbILUdJFfCEAn4VutSU4bfLAlNLdUFhpaLyaBxUVSJcgmhS4nFLTAmGBFUzMFLDatE0UDSBUAQuTSDU1PPougAVTMvC7UpFy5aUePTU+HpLgK4JElYqd6xpgqRMXaNqKbPuJBaqejDqFaAqEJOpfLZ+8N+WMHGpSqqBwzLQBCRVBSEtFBVMoaCrIFSRek1VYmCicjBlIFIbgaaSuiUUUIVEESAVE1WminOphIxAU8C0JKgWmpoqZKKb6IAlBQkkPgV0zSJmSLy6edB0R0NTTFRLYloQaXLjMjSErmOoGi5VQVUFBwyJJU3G6SqbEyYakkVePeV0Biz2aNQbJneND3Cab3D2gZ2dnVRXVzNu3DimT5/uSLrSGyc6Ozudxon01IQ9q2w4Yc8y3Lt3L+Xl5d00xOnXRKNRZ23r169n1apVJBIJysvL+eY3v8kpp5zSb6rwKMLxS7ptbW3s27ePcePG9atIsLFhwwYWL16ckelGbW0teXl5vP73Qv5dmbrhfQFJrAvMGHizLQ7sVol1Qv5kaNimoGoS3YCwC4QE3YIuLyhSoguTiEtN5TqFRVyqqAmJ5reIx1W8Xot4AhSXQNVSg/sSisSwJF4XhA2BROJ3CyIGuHRQNUABj1uiuSS6C3QNvB5wuyUuHbICEpdLEHBDwC/xe8DvMuhs24OVCLJo7lQKxmURDqduVvuImH6zZlI0GSrC4TA1NTX4fD5KS0u7yQDj8TgHOkI0doTY19lFayJBXPOieX0YXj8xlwdF1QhaFh1JC01V6JAGcQssRSEiTZJI4lhIJIYAS0hAYimpz5WiClQkSSSqauFWBAlpIQ4Ou7QU0KSCrqUkKopInUJURRKPaMQ7XGRZJo1SEBEKJRg0azohFKZpAq8qCEtJjiLI0wQ5isI3crzMdGd+jDZNk4aGBjo6Opg9ezaBQGDAxxiGQTgcdsguHA4DdCuI9dXBlgm6urqorq4mEAhQVlaW0fPE43FWr17Nm2++yfe//31isRgbN27kE5/4BKeffvphrWOUceyTrmEYvTqE7dmzh9raWoqLiyktLR2w0rtx40bmzJmDx+MZ8DUbGhrwer0UFU3g8dtV3vuHCopk0jyLHVtVhCqZPNeiYauC7k79e3+DgtUJmiaJRZRU95fHJGGp4JaoSUHcIzERqZywSI37dmkmcUNB0y1ULVX08mWBz6uSNS6lKsjNleSNk+SNg6IiSVEhDLY4LaVk79697N69m6lTpzJhwoQ+o367y6knEdskPFzHV8MwqK+vJxQKUVFRkXHxxM5z2mQSjUadPKf91Z/eFFLvR4cp2Zc0aUoYtJgmHVLQHI+xJxgipqtoPj8xJUXWCQEJTCxFIkWKrFUFJKlNUo/reJIuXIpCY8JAkxYBK8l+KfBYJuOExKVrnOzW+VJ+Fv5BKBNaW1upq6tj4sSJTJo0aUiFst7ysJZldWslzsrK6jc4kVKya9cumpqamDVrVsa62qqqKm644Qa++MUvcvPNNw9qBtpRhOOPdG1Fgt0Vc+KJJ2b0PB988AEzZszIKELYuXMniqJQUlJCIm7x+3tdNO9QcKmg+yThNkEiJMguljT8W8FMCvQ4GFmpo76uJDFVgYqKUFMSKH9OKueXWyzx5kryCiUFUy3yJkimVkiyciwnKrHJBOgWcR7u8dD2Gs7Ly2P69OmH9WE3DKMbEUciEUdGlB4RZ0IIUkr27dvHjh07mDJlCiUlJUOuuPcsOPUk4qysrH6duizLYvv27bS0tFBRUdEvkZiWxZ6kwR7T4oBlcMA0aLFSs9hUC3ShErNS0yz8iopfwGwhmRXrInbwVJFIJPB6vd3ev56BQyKRoLa2FtM0qaioyChgOBzYHWzpMjF7fHp6nljXdcLhMNXV1c5nKZPoNhaLsWrVKt5++20ee+wx5s6dOyJ/xyjh+CHdnoqErKwsNm7cmDHpbtmyhZKSkgF3ZTsibGlpYfLkyWRlZSGEyltParz2Mx23X1I4K6VjlQYEGxSSEdADEitp4JsYYtw0LyUzdaYstsifJsmbAIfDKXZUkk7Egzn6R6NR6urqsCyL8vLyYZ0HBd3ziKFQyNFz9oyIe47XrqmpIRAIUFpaOqKV6v6I2H4PvV4vbW1t1NXVUVxczJQpU0alAGU3DqSvL10iZhgGra2tlJWVHZFcp5SSSCRyyP+vZVkUFxdTUFBAVlbWgCfMyspKbrrpJi666CJuuummj2p0m45jn3TtjpaWlpZuigQpJW+//XbGigQ7T9uf6Nr2HE0mk+zbt8/Z9W2i081cWtYXEGv2kFMiCZRI3FkGZsEe9jXvZdq0aRQXF4+oI7999A8Gg31GnB6Ph507d9LS0kJZWVlGDSTDhd6IWNM0/H4/XV1dGIbB7Nmzj5gO0xb+h0IhOjo6CAaDCCEoKioiLy/PIeLRnKpgQ0pJR0cHNTU1QMrgJpFI4Ha7u20UA6VOhht28S4/P5+ioqJuUbG9UaQX62xlwt13301lZSWPPfYYs2fPHrX1jjCOfdLdt28f4XCYiRNfieEMAAAgAElEQVQn9qpIyJR0Gxoa8Pl8FBcXH/I7uzvGLtj1nLGUfrQOBoNORKfrOp2dnRQWFlJaWnrEdnGb6ILBIM3NzYTDYdxuNwUFBeTk5BxxItm9ezc7d+4kJyfH8QDQdb1bRDya67PX1NjYSGlpKTk5OQ4Rp0fE6RvZSK/Pnly9f//+Q9IbPVt1+4rYh3t9lmXR0NBAe3t7n8W7nlrit956i3vuuYdYLMbs2bO58sorOeWUU3q97z6iOPb9dAsLC/udCpEperN3HIhs0x+bl5fnrCMUClFTU4NpmhQXFxOJRKisrMTlcjkkZ+foRoNIdF1H0zRaW1vJyclh0aJFAM6Nun//frq6ugZdbBoq7PcpOzubk046qdumlEgkjsj6gsEgNTU1jBs3jmXLljk5yfHjxzN+/Phu67NJ2F7fSG0U9prGjx/PsmXLDgkuPB4PHo+n2yktHo8f8v7Z60vX6h7u+oLBIFu3bqWoqIglS5b0mXIRQjjry8rKYuvWrUyePJkf/ehHhMNhqqqqGD9+/LFEun3imIl0LcvqdfIvDE57m95MkSnZ9oSdV47H405eOR32jm8f/e2jVzoRZ+KKNhjE43G2bdtGLBbrdU29rc/+isViztHVXuNgx073hkQiwbZt24hGo1RUVGRUvLQf11vEORxEnEwmqa+vJxKJDGpNva3PJrueRDxYcxhbvdHZ2cns2bPx+/2DXlPP9aVHxOk59nTPhP7WZ5qmoygZzJrefvttVqxYwSWXXMJ11103quPdRxnHfnqhP6exwWhv7WaK0tJSx3AjU7K1p1bYnW7jx4/PuEpvF0tsIk4mk/j9/m5EcjhpCfs4um/fPmbMmJHR2KLe1teTiOPxOF6vt9v6Mt0o0mVpw+UD0N9GkcmJIl0pMZBU7nDQHxH3F3EeOHCAbdu2MXnyZCZOnDhiJ46+ip3pTRN2Mba9vZ2amppBSdO6urr4wQ9+wAcffMAvfvELysvLR+TvOIpwfJPuxo0bmT17dkaOSq2trY7jUabSKyklTU1N7Ny5k0mTJvWaVx4s7KpwOpGk6yTtG6GvSEFKSUtLC/X19RQVFTFlypRhjSrSNwp7s0gmk458yP7qqTqwj8hDkaVlivQcp03E6cUcOyKORCLU1NTg8XiYOXPmqPX0p0ecPYnY6/Vy4MABVFVl1qxZw3KyGCwMw+i2UYTDYRKJBEIIJk+eTH5+/oD3iF3IXrFiBV/72tf41re+dSxHt+k4vkn3gw8+YPr06f0eqe1UgmEY7Nmzp9tun37s75mfa2trY9u2beTm5jJ9+vQRvWEtq3+Nbk5OjlP9r62txeVyUVZWNmK6zZ5IN8C2v0zTxO/34/P5CAaDSCmZNWvWkI/Ih7u+9Ig4GAw6ov/CwkIKCwuHLXVyuIjH486MP6/Xi2ma6LrerVg3lBzs4aK1tZXa2lomTZpEIBDoRsQ9569lZWWhKAqRSITvf//7bNmyhV/84heUlZWN6pqPMI590oW+7R2rq6spLi7utdA2UN42mUx2O/ZHo1Hcbjder5dQKITL5aKiomLYta2ZIr0rrKOjg7a2NizLcgo+OTk5R+QmTV/f9u3baWxsJBAIYBjGoCL2kYLdvVVcXExhYaEj+xtq6mQoiEQibN261dEm26eAviLi0SDiZDJJXV0d8Xic2bNn97qBp89fC4VCvPjii7zwwgt0dXVx8sknc8MNN7B48eJh2fwvv/xy/vSnP1FYWMjmzZsP+b2Ukuuvv55XX30Vn8/HU089xeLFiwF4+umn+dGPfgTA7bffzmWXXTbk9fSD44N0+3Iaq6urIycnp9tU4MMtksXjcerq6ggGg2RnZ5NIJEgkEvh8vm4R8WjKwnq27hYUFBzSFabrerf1jYaGs6Ojg9ra2kNMV+zOJnsjsyP2nkQ8Es0HsViM2tpapJR9dm/1TJ3YnWG2A9ZwE7FlWU4tYNasWRlPORlpIrbzyYPRlYfDYb73ve9RW1vLf/3Xf9HS0kJVVRVXXnkly5YtO+y12PjnP/9JIBDg0ksv7ZV0X331VX72s5/x6quvsn79eq6//nrWr19PW1sbS5cu5d1330UIwZIlS6iqqhoWxVMfOPYlY/1B13VHBpY+sXQwRTLboayxsZFp06Yxd+5c53Hpx+rm5ma2bdvmRHM20Y0UidhdUra0ySb7ntNg7UJOMBiksbHRKTT1lK4NB+yNKZlMMm/evENOAXYTSXq6J72rzp5Wa5tfD4ehTrrmtqysrJvsqyeEEHi93oO+GkXO420HrPTZYQPlsAeC3eRQWFjYqwysL7hcLvLz87s1tNinslAoxIEDB4hEIo6V42CIOJFIUFNTg5SSxYsXZ/S5kFLy5ptvcsstt3DVVVfx8MMPj8jn/VOf+hQ7duzo8/cvv/wyl156KUIIPv7xj9PR0UFTUxPr1q3jjDPOcO6JM844g7Vr13LxxRcP+xoHwjFFunYHWk9omkYymXQ6yWyyzbRIduDAARoaGigqKuLEE0885CgshMDv9+P3+5kwYQLQPf+6Z8+ebh1rNtFl6kHQG+zWXSklJ5xwwoDpDZfL1U1jmp7f7OjoYNeuXUMmEXtjampqorS0dFCjVOzceXqUl5462blzJ+Fw+LB8HPrS3A4GQgh8Pl+3xhl7s+3s7HQKsLYnbHrE3tt7aBiG066eyf9fJtB1fUAi7tmCbasS7Pdw//79NDQ0MGPGjIzbijs7O7njjjtoaGjgpZdeOqKj0ffu3cvkyZOd7ydNmsTevXv7/PmRwDFFun1B0zTniKgoSsbRbSgUora2Fp/Px6JFiwYVCaa7bdlTK+yOtWAwSENDg3PsT9e/DnTst3Okdr/94bbupovV7bSLHc0Fg0FaWlpoaGhwCmHpRNwbadkRty3cH44cbW9jw+2KeigUct5DO5rr2VWXTCbZtm0bXV1dzJ07d9iLd+mbbU8itkmuvr6+mylMdna2UyybOnUqFRUVI5rm6Y+IOzs7HSK23y+Xy8Xs2bMzSnFIKXnjjTe49dZbufrqq3nkkUdG1RD9o4pjmnTtNEJWVhbNzc1UVVUhhHA+/H0VmezmhkQiQUVFRb+qh8GgZ8ca9H7st2VN9hpdLlc3HemkSZMGdRTNFOnRnB2x29K1YDDIvn37HGOcdMlVU1MTlmUxf/78IQ06zASaph2SOkmP5uyuK1vNUlxcnLFccDjQ26nHfg9bW1vZsmULhmHgdrtpbW0lmUw6Eedo1QHSidj+XG3fvp2SkhIURWHXrl0DNkx0dnZy++23s2vXLl555RWmTp06KmsfCBMnTmT37t3O93v27GHixIlMnDiRdevWdfv5KaecMvoL5BgrpNlOY/0VyUzT7KZGiEQiTjdTIBAgGAzS0dExqOaG4URv+tdYLOYcW6dPn05eXt4RdWGyLItQKMSOHTtob29H1/VuHgS2dO1IKCZsBYDb7Wb8+PGO1rm3ZonRlNLZUxPsfHJPHbZtk5guverrVDFciMViVFdX43a7e9Un99Yw8fDDD5NIJPj3v//NFVdcwW233TasMsm1a9dy/fXXY5omX//617nlllu6/f7GG2/kr3/9K9u3b2fy5Mk0NzfT0dEBpE5GU6dOpaWlhU9/+tOsXLmS6667jg0bNtDW1saSJUvYuHEjAIsXL6aqqqrXCRbDhONDvZBMJh1J0mCKZPF4nO3bt7Nv3z5cLpcT8aUfWY8Eydmtu9FolClTpnQ7WqdHmzk5OSMyYqUv2HKroqIipk6diqIozmbW00c3PWIfSTMYO+3S1tZGRUXFIcfj4e6qyxThcJitW7eSnZ1NaWlpvySa7ldrE/FIyOtstcuePXuYOXNmximqUCjErbfeSmNjI0uXLqWhoYGGhgbeeuutYdkcTNOkvLycv/3tb85p7tlnn2XOnDnONRdffDHr1q2jpaUFv9/PvHnz+MpXvgLAzTffTGdnJ9dccw1r167F5/Px5JNPsnTpUgCeeOIJ7r77bgBWrlzJ1772tSGvuR8cH6S7YsUKAoEAS5cuZcmSJQc9bvu/ye3mhry8PKZNm4au691ym+ki/9FQI0BmrbuWZXWLQuxC3UCpk6EgGo06o+pnzpw54JE9/dhvR0ojYfbT0tLCtm3bKCkp6XXuXV/oTxo2FEUC/J/ZeWtrK7NmzSI7+/AsKtPldbYWVkrZjYgHM0onGo2yZcuWQY3OkVLy2muvsXLlSq6//nq+9rWvjchn/+233+bOO+/kr3/9KwCrVq0C4NZbb+31+pNPPpnvf//7nHHGGUBKcmiPGjoKcHyQbk1NDe+88w7r169n48aNJBIJ5s2bx5IlS1i2bBlz5851bqD29nZ27NiBqqoZEUi6GsHuZLLzwzaJDJXkerbu2lFkpkiPhHumTux1Hg7JWZbFzp072b9//6Aio97QsyNsKGY/sViMmpoahBCUl5cPS7qgr666nkTc38nH9iaYMGECkydPHnaC6tmZGA6HDyHinkFBumRuMKNzgsEgt912G83NzTz66KPdFADDjeeff561a9fyq1/9CoBf//rXrF+/noceeuiQa3fu3MnHP/5x9uzZ42wcmqaxcOFCNE3jlltu4fOf//yIrTUDHB863YqKCioqKpxOk1gsxvvvv88777zDww8/zIcffoiu6+i6jtvt5r777mPWrFkZ3RR9qRHsD75dJT9cNy57vJDL5WLhwoWHRSC9FZkSiYQTsacX6jIlOTuKLC4u5sQTTxwygdj+vbacLD3abG9vd/Sv/Zn9pEvThroJ9ER/hbDedNjpJGdZFnV1dcRiMRYsWDBixbv0z6KN9JNPus45EAjgdrs5cODAoCRzUkr+9re/cccdd3DTTTdx6aWXHlXKhDVr1nDBBRd0+1t27tzJxIkTaWho4LTTTuOEE06gtLT0CK6ydxxTke5AeOGFF7jzzjs555xz8Hg8vPvuu45JzbJly1iyZAlLly4lLy/vsCPWeDzukFwwGBywW822Euzs7KS8vDwjqc5QYJNceurEdjRLX6MtkLdPAqNVdLLX2NXV1a1jzU7v6LpOa2srBQUFzJgx44iZp/TsqmtvbycWi5GdnU1xcfGIp6Aygf3ZOnDgAIFAwDGrsTcLu+DZc40dHR3ceuuttLW18eijjzJx4sRRWe9g0guLFi3i4Ycf7nM4wVe/+lU++9nPcsEFF4zcgvvH8ZFeGAh79+5l3Lhx3SIQuwVz/fr1rF+/nnfffdfxLbVJeMGCBYdNOunHVfsGtYtgdvFpxowZw24lONg12gRia3STySR5eXmOCcxoFup6Qzwep7q6mq6uLgKBANFoFDjU7Ge01xiLxdi6dSu6rlNaWtotfZI+yjy9IWY01pg+Omf69OnOa/Y1wTkSifDvf/8bj8fDk08+yYoVK/jKV74yrGsdSJnw+OOPc9VVV1FeXo6u67S3t7N27Vrmzp3bzTfh8ssv57HHHmP79u3OPdPe3o7P58PtdtPS0sJJJ53Eyy+/3K0IN8oYI93BIJlMsmnTJoeIP/jgAzRNY/HixSxevJilS5cyc+bMw46yWlpaqK2txePxoOv6qFf6e0N6511JSQkTJkzoFm2md4MNVw4703XZtpk9PQB6I5D0jrWRNPtJz5GWl5f3KT3KZEz9cMrr0gt4s2fPzkhjbpom77//PnfffTf19fXOdIdrr72W5cuXD8u6MlEmPPXUUzz//PPOZOPLL7+clStXsmLFCp555hmqq6sRQjBjxgwuu+wyfvrTnzqPfeutt/jGN76BoihYlsUNN9zAFVdcMSxrP0wcHznd4YKu6w7BXn311Ugp6ezs5N1332X9+vX88Ic/ZNu2bRQWFjrR8NKlSwc047ar/wALFy7s1vrZc36ZnR+2Cc5ukhgJdHV1UVNTg67r3Trverbl9rZGu1CX3lE3XLA1t36/n6VLlx6iIhioY82eADHcZj+dnZ1s3bqV3NzcAXOkg+2qG4pZTSgUorq6msLCQpYuXZpxm/tf//pXvv/97/Pd736XL33pSyiK4kyUGC5s2LCBsrIyZsyYAcDy5ct7jUSnTZvGn/70p24/W7x4MaFQyNnYLrzwQj72sY91u+bkk09m06ZNw7bekcQY6WYAW6Vw2mmncdpppwGpD2tjY6MTDT/yyCO0tLQwc+ZMR7K2ePFifD6f4x0QjUaZOXNmr1GRruuHFMHsAlO6N0LP3OtQcprp2tby8vIBK9q9rTF99NCePXu6aV/tdQ5WcjWQ5rY/9FVMtEluKGY/pmnS0NBAR0cHs2bNOuxOxYG66npuaANtFunrmjdvXsbtzm1tbXz3u98lGo3yv//7v07hEDjEkGio6M37YP369Ydc98ILL/DPf/6T8vJyfvKTnzB58uSjyjdhODBGuocJIQQTJ07k/PPP5/zzzwdSH/7q6mrWr1/PH//4R26//XZaWlowDINLL72Uz33uc4PSa/bmjWBX0e2WXCnloPOaUkqam5tpaGhwjnqHG/n1pkaw3bh6+jeka5z72ixsv4KSkpIhrSsd/Zn9BIPBjMx+2traqK2tpaSkhKVLlw57yqI3j4S+nOHS12jnlAezLiklf/7zn/nhD3/IbbfdxvLly49YPSEdn/vc57j44otxu9089thjXHbZZbz22mtHelnDjjHSHUaoqsq8efOYN28el19+OZ/97GdZtmwZ55xzDjU1NTzwwANs3bqVnJwcRzu8dOnSjMf72JXnQCBASUkJ8H+WiMFgsJsTV3paIj1CSh9Ns2TJkmFPWfTmxpXeadXY2NjrxAtN05zGi8GaCx3OGvsy++m5WXi9XmKxGEIITjjhhFGdeNFzswC6zdKrqalxvBuSySQtLS0DpqFaW1tZsWIFhmHw97//PWMnsaGiL0+EdKRvOF//+tf5zne+4zz2aPFNGA6MFdJGEMFgsNd21JaWFictsWHDBvbu3cu0adOc3PDixYvJyck57Oijr2kXpmk6Jj79+cmOBuwCUzAYpKmpiUgkgtfrJT8//4gVE9NhF/AaGhocMrDbctOtJY+ELMyOuidNmkRJSckh7c09o3Z7E37llVe4++67WblyJRdddNGovreGYVBeXs4//vEPJk6cyLJly/jd737H3LlznWuampqcFMcf//hH7rnnHt55550j4ZswHBhTLxzNsCyLbdu2OSRcVVXl2BHaRDxv3rzDiv5sF6mGhgbHKCcUCmEYhtOAkJOTc0RG5tgG3uPHj2fatGmOkY69YdibRc+OupFGNBqlurq610GVPduve5qtj6TZj2EY1NbW9js6Bw7tqvvWt77Frl27UBSFyy+/nFNPPZVPf/rTw7augaRgDzzwAL/61a/o6uqiubmZgoICrrrqKlauXIkQgmnTppGTk+N0UNo570ceeYRZs2YBo+6bMBwYI92PGhKJBO+//75DxJs3b8bj8bBo0SKHiGfMmNFvlBUOh6mpqcHn81FaWtrt2JmuzU0fmTMa5GHP3YrFYlRUVPR7ZO/puDZc3gi9Id3zoqKiIuNRLqNh9tPS0kJdXd2gxsNLKXnppZdYvXo1K1euZP78+VRVVdHQ0MD3vve9w15LOjKRgr3++ut87GMfw+fz8cgjj7Bu3Tqee+454KjzSxhOjJHuRx1SSjo6OqisrGT9+vVUVlbS0NDAxIkTWbx4sdNRN378eNra2qivr0cIQUVFRcbFu/Qjv00emqZ1yw8PxaAmXXM7ffr0ASV2fT1Hb94IQ3XiCoVCbN269ZBmgsPFcJn9JJNJampqME1zUKPYm5ub+fa3v42u6/zsZz8b1BSPwWCwJjXvvfce11xzDf/617+A45N0xwppHxEIIcjLy+PMM8/kzDPPBP7Pg+Cdd97hX//6Fz/5yU/YsWMHUkouvPBCzjnnHDRNc2wuB0JvmtLeKuiHIwmzLQ5tF7jDjU77Go1kR+3phbr0aDgQCPQpt6qvrycUCjFnzhwCgcBhrasnelMjpOdebXldfz4Yzc3N1NfXM2PGDAoLCzOObl988UXuvfde7rzzTs4///wRzd1mKgWz8fjjj3P22Wc738diMZYuXXq0mNSMCsZI9yMMRVGYOnUqU6dO5aKLLuKiiy5iwYIFXHTRRWzZsoU1a9Zwyy23IIRg4cKFTiNHRUVFxpFgb3Ir27uhtbXVqfKn9/OnF5fSNaSDiboH+z70NujSjtp37NjhHPnTCS4SiVBfX8/EiROZOXPmiBeWMjX78Xq9RKNRdF1nwYIFGc9P279/P9/+9rfxer28/vrrR7xY2hO/+c1vePfdd3njjTecn31UTGqGE2PphWMI4XD4kEhNSkk4HKaqqspJS9TW1pKfn8+SJUtYsmQJJ554YsYjtntDbyPVhRDouk44HGbChAkD5p9HA/aRv62tjaamJgzDIDs7m7y8vEE1SYwU7PTL9u3bnekSPSdK9JY+sSyLF154gR//+Mf84Ac/4POf//yoKRMyTS/8/e9/59prr+WNN95wZHo9cRSY1Awnjt2c7kCV03g8zqWXXkpVVRX5+fk899xzR3Ra6dEAW9GwYcMG3nnnHSorK9m3bx9lZWWOfnjRokV9HskHQjQadfKQubm5RCKRbt6+I9EynAnSc8r2tOL0Jol0uVVfrnAjhXTjHNvwxUZvmxqkiAxSxDdhwgQefPDBYbW5hIHvr0gkQlFREfn5+RQWFhIOh3n++eeZO3cuq1at4vHHHyeZTJJMJnnjjTeYOXOm89ij0KRmOHFskm4mldOf//znfPDBBzz66KOsWbOGP/7xj07ldAz/B9M0qa2t5Z133mHDhg289957JBIJTjjhBIeI58yZ028uNr3635vPbbq3r21gPlpjkbq6uqiursbv91NWVtbn6/TlCjdSU0PsdvJdu3ZRXl6eMWkmk0kefPBBXn31VbxeL8FgEI/Hwx//+Mc+I8nBItP7609/+hPbtm0jGAxSWFjIpk2buPrqq/nLX/5CTU0Np512GuvXr2fevHkATJkyhVdeeeVoNKkZThybpJvJ0eass87izjvv5KSTTsIwDIqLizlw4MBR0fZ4tCMWi/Hee+850fCHH35IIBDoZvIzZcoUFEWhrq6OtrY2CgoKmDZtWsZmKyM9FsmeetHc3ExFRUXGExN6Pkf61BB7NFJPy8bBfqZsPbDP5+t3I+iJffv2cf311zNu3Dh+8pOfOE0CoVBoWC04h3J/rV69utu16dcdJzg21QuZVE7Tr7HlT62trUddkeFohMfj4aSTTnJuFCklra2tVFZW8s4777BmzRoaGhqc5oDbbrttUAWp3ka+pxPcnj17us1+G6ylZDAYZOvWrRQUFAxpZH1fU0PsQp3tFKbr+iHpk97WmT4deDB6YMuyWLNmDQ8++CB333035557brfnH+4i5VDur7179/Lxj3+822M/yiY1w4mPNOmOYXQhhGD8+PGcffbZnH322VRVVXHFFVdwxRVXMG7cOF5//XXuu+8+wuEwc+bMcSLi+fPnZ5y/zXQskq157W0skmEY1NfXEw6HB+W6NRhomkZeXl43wuxNXufxeLo1SSSTSaqrq8nOzs54dA6kWmSvv/56CgoKeOONNzIm6jEcffhIk24mJhr2NZMmTcIwDILB4GEXGzJtd9Q0jYKCAp544gmmTp16WK/1UcCcOXN48803HanWl7/8ZSBFPrYJ/JNPPsmmTZscr147P1xWVpZx5NmbFWJ6AWz37t1OfljTNNrb25k6dSrl5eWjmkbqS15nS8JqamqIx+Pk5ubicrkIBoMD5rEty+J3v/sdDz30EKtWreKcc84Ztb9pKPdXJo89XvGRzulmYqLx8MMPs2nTJqeQ9uKLL/L73/9+0K811HbH4xlSSkKhkGMCv2HDBmficXp+ONMGgN4Qi8XYsmULyWSSQCBAJBJxzGnsaPhIjRwKh8NUV1eTl5fH9OnTHTcz+yvdRMduv1ZVlcbGRq677jomTJjA/ffff1j56EzQ1tbGRRddxI4dO5g2bRq///3vycvL63Z/tbS0cMopp1BcXIzf73dMcx5++GEefPBBEokElmURDAZZt24duq7zpS99iQ0bNtDY2MhnPvMZ6urqjthMuyOAY7OQBvDqq69yww03dBvvcccdd7B06VLOO+88YrEYl1xyCe+99x7jxo1jzZo1jnv9YDDUdscxdIeUkr1797J+/XqnUNfa2kp5ebljAr9o0aIB87f28+zevZuysrJu7a7p5jTBYNCxvRytsUj2/L2WlpZ+R+f0NNFZtWoVH374IR0dHVxyySVcccUVVFRUjNiG8Z3vfIdx48Zxyy23sHr1atrb27nnnnuA/7u/YrEYF1xwAQ888AA33ngjTz31FNu3b8fj8TBr1ixisRhTpkzpdn/dddddPPHEE2iaxk9/+tNunWjHAY5d0h0tPP/886xdu5Zf/epXAPz6179m/fr1PPTQQ71ef80111BcXMztt98+msv8SMM0TbZs2eJEw++99x5SSubPn+9Ew7NmzXKO4+3t7dTX15OVlUVpaWlG1f/0kUO2J8JIjEWyvRwKCgqYOnVqxoS5Z88errvuOkpKSvjCF77Ali1bqKys5N577x0xfXlFRQXr1q1jwoQJNDU1ccopp1BTU9PvYxYsWMDzzz/PzJkzj7WmhuHCsaleOFrRW7vjGAaGqqqccMIJnHDCCXz96193NLNVVVVs2LCB++67j5qaGsd4p6uri0ceeYSysrKMo9WRHotkWRYNDQ20t7cPysvBsiyeeeYZHnvsMe677z7OOOMMhBCce+65GT1+KNi/f7+jHikuLmb//v39Xr9hwwYSiUS3dt2VK1fygx/8gM985jOsXr36iHb2He0YI90MkWlh4O9//zt33XUXb7zxxtgHb4iwzW0+9alP8alPfQqAzZs3c8kll1BaWkpJSQkrVqygsbGR6dOndzOBz87OzpiIe5siYU9CHsxYpI6ODrZu3cqECRMGNdJn9+7dXHvttcyYMYM333xzRPwpTgCvQHkAAAurSURBVD/9dPbt23fIz++6665u3wsh+l13U1MTl1xyCU8//bTz969atYri4mISiQRXXXUV99xzD3fccUe/66msrOSKK65gw4YNmKbJiSeeyHPPPec0UBzLGEsvZIhMinbvvfceF1xwAWvXru3W7jiG4UNzczOdnZ3doizbBN7upquqqiIWix1iAj+UtEH6WKT0ce85OTkEAgHa29uJRqPMmTMnY4May7J46qmn+OUvf8n999/PZz7zmSPStJNpeiEUCnHKKadw22239ZlKWLduHT/+8Y8PmejbG26//XZisRjRaJRJkyb1WR/5iGIspzscGKhod/rpp7Np0ybnqGa3Ox4uBpKo2XjhhRe44IILqKysZOnSpYf9escS4vG4YwJfWVnpmMAvXrzYIeKh+uYmk0n27t3Lzp07HUK3dbl2aqIvot+1axfXXHMN5eXl3HvvvcNmKXk4WLFiBfn5+U4hra2tjXvvvbfbNYlEgrPPPpvPfe5z3HDDDd1+Z4/ZkVJy44034vF4nI60/pBIJFi2bBkej4e33nrrWFM2jJHuRw2ZSNQgNbfr3HPPJZFI8NBDD42Rbh+wTeA3bNjgEPH27duZOHGiQ8JLliwhPz8/o2jTMAzq6uqIRqPMnj0br9frTBlO95dIH4u0f/9+Zs2axXPPPceTTz7J/fffz2mnnTZi0W1fUrCeUBQFv99PIpEgOzubmpoaxo0bx8svv8yVV15JdnY248ePp6qqqtvJ7qmnnmLhwoWcdtppHDhwACklCxcu5NFHH81oE2lqauL//b//h9vtprKyclSHfo4Cxkj3o4ZMJWo33HADZ5xxBvfddx8//vGPx0h3ELANeuy0RGVlJcFgkFmzZjlNHAsWLMDr9XZ73GBG56SPRfrv//5v3n77bWKxGJ/73Of4xCc+wZe//OVhn8hsoz8pWDr6mt5w4YUXcv7557N8+XK++c1vsmDBAq6++uphW995553H8uXL2b59O01NTX0qgT6i6PNDcWQNTsfQJ3rre+/Zu75x40Z27949KhXuYxGKojBt2jSWL1/OAw88wJtvvklVVRW33XYbOTk5/Pa3v+XMM8/k05/+NDfccAOPPvooX/jCF/jXv/7FokWLKCkpGTBKFULg9Xr585//zNatW3n66adpaGjg8ssvp7Ozc0RtI19++WUuu+wyAC677DJeeumljB8rpeS1115zcreDffxAeOaZZ5wGiltuuYXKykpee+21YXv+oxlj6oWPKCzL4qabbuKpp5460ks5pqDrOgsXLmThwoV885vfdEzgH3zwQe677z7mz5/PXXfdxS9/+Uunm27ZsmV9znvbvn071157LSeccAL/+te/nCP0ySefzMknnzyif0umUrDeRua0traSm5vrbArDbVhz6aWXcumllwIpqWB/I36ONYyR7lGKgSRqnZ2dbN68mVNOOQVI2f2dd955vPLKK2MphmGEEMJpH/7ggw8oKChwzNBtE/hf/OIXNDc3OybwS5cuZcGCBTz77LP8+te/5n/+53/45Cc/OSK52+GQgvU2MicnJ2fY1zqGg5BS9vc1hiOEZDIpp0+fLhsaGmQ8Hpfz58+Xmzdv7vP6T3/607KysnLIr/uXv/xFlpeXy9LSUrlq1aper3nuuefk7Nmz5Zw5c+TFF1885Nc8FmAYhvzwww/lE088Ib/xjW/IqVOnyi9+8YsyEokcsTWVl5fLxsZGKaWUjY2Nsry8fMDHXHbZZfIPf/iDtCxL5ufny2QyKaWU8q233pJnnnnmiK73GEOfvDpGukcx/vznP8uZM2fKGTNmyB/96EdSSin/+7//W7788suHXDscpGsYhpwxY4asr693iP7DDz/sdk1tba1cuHChbGtrk1JKuX///iG95rEKy7KO9BLkzTff7Gycq1atkitWrDjkmra2NhmLxaSUUh44cECWlZU5/+cXXHCBfPbZZ6WUUn7jG9+QDz/88Cit/JjAGOmOYWD0jGbuvvtueffdd3e7ZsWKFfKXv/zlaC9tDGlobW2Vp59+uiwrK5Onn366swGm47XXXpNz586VgUBAulwuKYSQzzzzjJRSynPPPVcGAgG5YMECWVZWJsvKyuT8+fPlvHnz5K9+9SvnOerr6+WyZctkaWmpvOCCCxxyHkNG6JNXx3K6Y3CQyaSA2tpaAD7xiU9gmiZ33nkn//Ef/zGq6zzesXr1aj7zmc84UrDVq1cfIgU79dRT2bx5M5DS65aVlfGFL3wBgPHjx/Pkk08OaFAzY8YMNmzYMDJ/xHGMMcnYGAYFuylg3bp1PPvss1x55ZV0dHQc6WUdVxisFOz555/n7LPPzrg9eQwjizHSHYODTEx9Jk2axHnnnYeu60yfPp3y8nLq6upGe6nHNQbrCrZmzRouvvjibj9buXIl8+fP58YbbyQej4/YWsdwKMZIdwwOli1bRl1dHdu3byeRSLBmzRrOO++8btd8/vOfZ926dUCqM6u2tvawTOHTsXbtWioqKigrK+u1Z3/Xrl2ceuqpLFq0iPnz5/Pqq68O6fU+Cjj99NOZN2/eIV8vv/xyt+sycQXbtGkTZ511lvOzVatWsXXrViorK2lra+u1S20MI4j+Er5HJP08hkGjvb192CrLAykmLMuSN954o5w9e7acN2+eU90+XGSimLjyyivlz3/+cymllB9++KGcOnXqkF7zo47BSMF++tOfyiuvvLLP37/++uvy3HPPHfY1jqFvXh2LdI8BdHR08POf/3xYnuucc86htraW+vp6Vq5cCcAPfvADJ+IVQvDAAw+wZcsWNm3axPLly4f0ehs2bKCsrIwZM2bgcrlYvnx5r9FcKBQCUmPVS0pKhvSaH3Wcd955PP300wA8/fTT/Od//mef1z777LOHpBaampqAVMD10ksvHRcetkcV+mPkI7E9jGHwuOiii6TH45ELFiyQN99885FezqDwhz/8QV5xxRXO988884z81re+1e2axsZGOW/ePDlx4kSZm5sr33333dFe5qjg97//vZwzZ44UQvSruX7uueek1+uVuq7L0tJS2draKqWU8qWXXpIFBQWytLRUXnjhhbKmpkaWlJRI0zS7Pf7UU0+V8+bNk3PnzpVf/vKXZWdn54j+XccpxiLdYxmrV6+mtLSU999/n/vuu+9IL2fY8eyzz/LVr36VPXv28Oqrr3LJJZdgWdaRXtawY968ebz44ovOlIzeYJomt956K5s3byYcDuP3+5024N/+9rc8+OCDbNu2jby8PP7xj3+wd+/eQzyDX3vtNTZt2sTmzZv5zW9+c0S9fI9HjJHuGI4oMlFMPP7441x44YUAnHTSScRiMVpaWkZ1naOB2bNnU1FR0e81faVj5Ai7go1h+DBGumM4oshEMTFlyhT+8Y9/AFBdXU0sFus2an2wuPzyyyksLOwzlyml5LrrrqOsrIz58+ezcePGw36t4UZflp8j7Qo2huHDGOkeA8jKyqKzs/NIL+OwoGkaDz30EGeddRazZ8/mwgsvZO7cudxxxx3OqKP777+fX/7ylyxYsICLL76Yp556akiOXV/96ldZu3Ztn7//y1/+Ql1dHXV1dfziF78YVuPuTKVgYzh2MdDkiDF8RCCE+B0wH/iLlHLFkV7P0Q4hxDTgT1LKQ8JdIcRjwDop5bMHv68BTpFSNo3S2tYBN0sp3+3ldycBd0opzzr4vT1KZDVwACiWUho9rxvD0YMx74VjBFLKLx3pNRxDmAjsTvt+z8GfjQrpDoBKYKYQYjqwF1gOfElKKYUQrwMXAGuAy4Cx8PkoxFh6YQxjOEoghPj/hBB7gJOAPwsh/nrw5yVCiFcBpJQGcA3wV6Aa+L2U8sODT/Fd4CYhxDYgH3h8tP+GMQyMsfTCGI5LHM3phTEc2xiLdMcwhkPxCnCpSOHjQHCMcMcwXBjL6Y7huIMQ4lngFGD8weP89wAdQEr5KPAqcA6wDegCvnZkVjqGYxFj6YUxjGEMYxhF/P/VmOynyZHRsAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape,t.shape,y_real.shape)\n",
        "print(X.shape,T.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gRKvROqlK8_i",
        "outputId": "de936f0e-0a40-4b51-9304-2343c5b72187"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([200, 1]) torch.Size([100, 1]) torch.Size([200, 100])\n",
            "torch.Size([200, 100]) torch.Size([200, 100])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Prepare Data"
      ],
      "metadata": {
        "id": "U66GsxSutJcB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Transform the mesh into a 2-column vector\n",
        "x_test=torch.hstack((X.transpose(1,0).flatten()[:,None],T.transpose(1,0).flatten()[:,None]))\n",
        "y_test=y_real.transpose(1,0).flatten()[:,None] # Colum major Flatten (so we transpose it)\n",
        "# Domain bounds\n",
        "lb=x_test[0] #first value\n",
        "ub=x_test[-1] #last value \n",
        "print(x_test.shape,y_test.shape)\n",
        "print(lb,ub)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ZN_Jc-gtR-q",
        "outputId": "4fa42c10-dbf0-4880-9bd2-27e8efce30e4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([20000, 2]) torch.Size([20000, 1])\n",
            "tensor([-1.,  0.]) tensor([1., 1.])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training Data"
      ],
      "metadata": {
        "id": "dQxdtgBtsqJj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Initial Condition\n",
        "#Left Edge: x(x,0)=sin(x)->xmin=<x=<xmax; t=0\n",
        "left_X=torch.hstack((X[:,0][:,None],T[:,0][:,None])) # First column # The [:,None] is to give it the right dimension\n",
        "left_Y=torch.sin(np.pi*left_X[:,0]).unsqueeze(1)\n",
        "#Boundary Conditions\n",
        "#Bottom Edge: x=min; tmin=<t=<max\n",
        "bottom_X=torch.hstack((X[0,:][:,None],T[0,:][:,None])) # First row # The [:,None] is to give it the right dimension\n",
        "bottom_Y=torch.zeros(bottom_X.shape[0],1)\n",
        "#Top Edge: x=max; 0=<t=<1\n",
        "top_X=torch.hstack((X[-1,:][:,None],T[-1,:][:,None])) # Last row # The [:,None] is to give it the right dimension\n",
        "top_Y=torch.zeros(top_X.shape[0],1)\n",
        "#Get all the training data into the same dataset\n",
        "X_train=torch.vstack([left_X,bottom_X,top_X])\n",
        "Y_train=torch.vstack([left_Y,bottom_Y,top_Y])\n",
        "#Choose(Nu) points of our available training data:\n",
        "idx=np.random.choice(X_train.shape[0],Nu,replace=False)\n",
        "X_train_Nu=X_train[idx,:]\n",
        "Y_train_Nu=Y_train[idx,:]\n",
        "# Collocation Points (Evaluate our PDe)\n",
        "#Choose(Nf) points(Latin hypercube)\n",
        "X_train_Nf=lb+(ub-lb)*lhs(2,Nf) # 2 as the inputs are x and t\n",
        "X_train_Nf=torch.vstack((X_train_Nf,X_train_Nu)) #Add the training poinst to the collocation points"
      ],
      "metadata": {
        "id": "KjFW76MDzRXP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Original shapes for X and Y:\",X.shape,y_real.shape)\n",
        "print(\"Boundary shapes for the edges:\",left_X.shape,bottom_X.shape,top_X.shape)\n",
        "print(\"Available training data:\",X_train.shape,Y_train.shape)\n",
        "print(\"Final training data:\",X_train_Nu.shape,Y_train_Nu.shape)\n",
        "print(\"Total collocation points:\",X_train_Nf.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ySJY_09LzRXz",
        "outputId": "92791612-a725-465c-b09b-341468825791"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original shapes for X and Y: torch.Size([200, 100]) torch.Size([200, 100])\n",
            "Boundary shapes for the edges: torch.Size([200, 2]) torch.Size([100, 2]) torch.Size([100, 2])\n",
            "Available training data: torch.Size([400, 2]) torch.Size([400, 1])\n",
            "Final training data: torch.Size([100, 2]) torch.Size([100, 1])\n",
            "Total collocation points: torch.Size([10100, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train Neural Network"
      ],
      "metadata": {
        "id": "I82eH55ElVSq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(123)\n",
        "#Store tensors to GPU\n",
        "X_train_Nu=X_train_Nu.float().to(device)#Training Points (BC)\n",
        "Y_train_Nu=Y_train_Nu.float().to(device)#Training Points (BC)\n",
        "X_train_Nf=X_train_Nf.float().to(device)#Collocation Points\n",
        "f_hat = torch.zeros(X_train_Nf.shape[0],1).to(device)#to minimize function\n",
        "\n",
        "X_test=x_test.float().to(device) # the input dataset (complete)\n",
        "Y_test=y_test.float().to(device) # the real solution \n",
        "\n",
        "\n",
        "#Create Model\n",
        "PINN = FCN(layers)\n",
        "PINN.to(device)\n",
        "print(PINN)\n",
        "params = list(PINN.parameters())\n",
        "optimizer = torch.optim.Adam(PINN.parameters(),lr=lr,amsgrad=False)\n",
        "'''\n",
        "'L-BFGS Optimizer'\n",
        "optimizer = torch.optim.LBFGS(PINN.parameters(), lr=lr, \n",
        "                              max_iter = steps, \n",
        "                              max_eval = None, \n",
        "                              tolerance_grad = 1e-05, \n",
        "                              tolerance_change = 1e-09, \n",
        "                              history_size = 100, \n",
        "                              line_search_fn = 'strong_wolfe')'''\n",
        "start_time = time.time()\n"
      ],
      "metadata": {
        "id": "8KZvgKcalOVV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e2e20425-51d1-475f-d44d-4a41ab0f1ef2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "FCN(\n",
            "  (activation): Tanh()\n",
            "  (loss_function): MSELoss()\n",
            "  (linears): ModuleList(\n",
            "    (0): Linear(in_features=2, out_features=32, bias=True)\n",
            "    (1): Linear(in_features=32, out_features=32, bias=True)\n",
            "    (2): Linear(in_features=32, out_features=1, bias=True)\n",
            "  )\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#optimizer.step(PINN.closure)"
      ],
      "metadata": {
        "id": "ZZoV9cCfiOOd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(steps):\n",
        "    if i==0:\n",
        "      print(\"Training Loss-----Test Loss\")\n",
        "    loss = PINN.loss(X_train_Nu,Y_train_Nu,X_train_Nf)# use mean squared error\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "    if i%(steps/10)==0:\n",
        "      with torch.no_grad():\n",
        "        test_loss=PINN.lossBC(X_test,Y_test)\n",
        "      print(loss.detach().cpu().numpy(),'---',test_loss.detach().cpu().numpy())"
      ],
      "metadata": {
        "id": "KM3GHnh9ljCh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9441a83-f3c9-4f3d-ed1d-cf39b7bab58f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Loss-----Test Loss\n",
            "16.872953 --- 0.21578383\n",
            "0.0023157867 --- 0.040029954\n",
            "0.00094095786 --- 0.03701073\n",
            "0.00093393784 --- 0.03686953\n",
            "0.00053550256 --- 0.03589083\n",
            "0.00013635051 --- 0.036152445\n",
            "0.00010098482 --- 0.036125004\n",
            "8.690708e-05 --- 0.03609807\n",
            "0.000118484546 --- 0.03610071\n",
            "7.326243e-05 --- 0.036075894\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plots"
      ],
      "metadata": {
        "id": "kpRh89zM8Te8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y1=PINN(X_test)"
      ],
      "metadata": {
        "id": "iezJgPG0UAto"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x1=X_test[:,0]\n",
        "t1=X_test[:,1]"
      ],
      "metadata": {
        "id": "otgA5_xXqb4S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr_x1=x1.reshape(shape=[100,200]).transpose(1,0).detach().cpu()\n",
        "arr_T1=t1.reshape(shape=[100,200]).transpose(1,0).detach().cpu()\n",
        "arr_y1=y1.reshape(shape=[100,200]).transpose(1,0).detach().cpu()\n",
        "arr_y_test=y_test.reshape(shape=[100,200]).transpose(1,0).detach().cpu()"
      ],
      "metadata": {
        "id": "90-ygJjca2c_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot3D_Matrix(arr_x1,arr_T1,arr_y1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "ituXQapsciqE",
        "outputId": "982cffba-812a-4fc4-baf7-42ef29c3f339"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot3D_Matrix(X,T,y_real)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "xarXcLDdeF7X",
        "outputId": "cb845f12-3d53-401f-d237-f963cf9b93ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## References:\n"
      ],
      "metadata": {
        "id": "K_21EpoD1fZi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "[1] Raissi, M., Perdikaris, P., & Karniadakis, G. E. (2017). Physics informed deep learning (part i): Data-driven solutions of nonlinear partial differential equations. arXiv preprint arXiv:1711.10561. http://arxiv.org/pdf/1711.10561v1\n",
        "\n",
        "[2] Lu, L., Meng, X., Mao, Z., & Karniadakis, G. E. (1907). DeepXDE: A deep learning library for solving differential equations,(2019). URL http://arxiv. org/abs/1907.04502. https://arxiv.org/abs/1907.04502\n",
        "\n",
        "[3] Rackauckas Chris, Introduction to Scientific Machine Learning through Physics-Informed Neural Networks. https://book.sciml.ai/notes/03/\n",
        "\n",
        "[4] Repository: Physics-Informed-Neural-Networks (PINNs).https://github.com/omniscientoctopus/Physics-Informed-Neural-Networks/tree/main/PyTorch/Burgers'%20Equation\n"
      ],
      "metadata": {
        "id": "SUFzJJ23ZR2O"
      }
    }
  ]
}
